a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsThObservables.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2019 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
9#include "NPbase.h"
10
11muggH::muggH(const StandardModel& SM_i, const double sqrt_s_i)
12: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13{
14 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
15 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
16}
17
19{
20 return myNPbase->muggH(sqrt_s);
21}
22
23muVBF::muVBF(const StandardModel& SM_i, const double sqrt_s_i)
24: ThObservable(SM_i), sqrt_s(sqrt_s_i)
25{
26 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
27 throw std::runtime_error("muVBF called with a class whose parent is not NPbase");
28
29}
30
32{
33 return myNPbase->muVBF(sqrt_s);
34}
35
36muVBFgamma::muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i)
37: ThObservable(SM_i), sqrt_s(sqrt_s_i)
38{
39 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
40 throw std::runtime_error("muVBFgamma called with a class whose parent is not NPbase");
41
42}
43
45{
46 return myNPbase->muVBFgamma(sqrt_s);
47}
48
49mueeWBF::mueeWBF(const StandardModel& SM_i, const double sqrt_s_i)
50: ThObservable(SM_i), sqrt_s(sqrt_s_i)
51{
52 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
53 throw std::runtime_error("mueeWBF called with a class whose parent is not NPbase");
54
55}
56
58{
59 return myNPbase->mueeWBF(sqrt_s);
60}
61
62mueeWBFPol::mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
63: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
64{
65 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
66 throw std::runtime_error("mueeWBFPol called with a class whose parent is not NPbase");
67}
68
70{
72}
73
74mueeHvv::mueeHvv(const StandardModel& SM_i, const double sqrt_s_i)
75: ThObservable(SM_i), sqrt_s(sqrt_s_i)
76{
77 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
78 throw std::runtime_error("mueeHvv called with a class whose parent is not NPbase");
79}
80
82{
83 return myNPbase->mueeHvv(sqrt_s);
84}
85
86mueeHvvPol::mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
87: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
88{
89 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
90 throw std::runtime_error("mueeHvvPol called with a class whose parent is not NPbase");
91}
92
94{
96}
97
98mueeZBF::mueeZBF(const StandardModel& SM_i, const double sqrt_s_i)
99: ThObservable(SM_i), sqrt_s(sqrt_s_i)
100{
101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
102 throw std::runtime_error("mueeZBF called with a class whose parent is not NPbase");
103
104}
105
107{
108 return myNPbase->mueeZBF(sqrt_s);
109}
110
111mueeZBFPol::mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
112: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
113{
114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
115 throw std::runtime_error("mueeZBFPol called with a class whose parent is not NPbase");
116}
117
119{
121}
122
123muepWBF::muepWBF(const StandardModel& SM_i, const double sqrt_s_i)
124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
125{
126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
127 throw std::runtime_error("muepWBF called with a class whose parent is not NPbase");
128
129}
130
132{
133 return myNPbase->muepWBF(sqrt_s);
134}
135
136muWH::muWH(const StandardModel& SM_i, const double sqrt_s_i)
137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
138{
139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
140 throw std::runtime_error("muWH called with a class whose parent is not NPbase");
141}
142
144{
145 return myNPbase->muWH(sqrt_s);
146}
147
148muWHpT250::muWHpT250(const StandardModel& SM_i, const double sqrt_s_i)
149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
150{
151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
152 throw std::runtime_error("muWHpT250 called with a class whose parent is not NPbase");
153}
154
156{
157 return myNPbase->muWHpT250(sqrt_s);
158}
159
160muepZBF::muepZBF(const StandardModel& SM_i, const double sqrt_s_i)
161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
162{
163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
164 throw std::runtime_error("muepZBF called with a class whose parent is not NPbase");
165
166}
167
169{
170 return myNPbase->muepZBF(sqrt_s);
171}
172
173muZH::muZH(const StandardModel& SM_i, const double sqrt_s_i)
174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
175{
176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
177 throw std::runtime_error("muZH called with a class whose parent is not NPbase");
178}
179
181{
182 return myNPbase->muZH(sqrt_s);
183}
184
185muZHpT250::muZHpT250(const StandardModel& SM_i, const double sqrt_s_i)
186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
187{
188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
189 throw std::runtime_error("muZHpT250 called with a class whose parent is not NPbase");
190}
191
193{
194 return myNPbase->muZHpT250(sqrt_s);
195}
196
197mueeZH::mueeZH(const StandardModel& SM_i, const double sqrt_s_i)
198: ThObservable(SM_i), sqrt_s(sqrt_s_i)
199{
200 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
201 throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
202}
203
205{
206 return myNPbase->mueeZH(sqrt_s);
207}
208
209mueeZHPol::mueeZHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
210: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
211{
212 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
213 throw std::runtime_error("mueeZHPol called with a class whose parent is not NPbase");
214}
215
217{
219}
220
221mueeZllH::mueeZllH(const StandardModel& SM_i, const double sqrt_s_i)
222: ThObservable(SM_i), sqrt_s(sqrt_s_i)
223{
224 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
225 throw std::runtime_error("mueeZllH called with a class whose parent is not NPbase");
226}
227
229{
230 return myNPbase->mueeZllH(sqrt_s);
231}
232
233mueeZllHPol::mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
234: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
235{
236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
237 throw std::runtime_error("mueeZllHPol called with a class whose parent is not NPbase");
238}
239
241{
243}
244
245mueeZqqH::mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i)
246: ThObservable(SM_i), sqrt_s(sqrt_s_i)
247{
248 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
249 throw std::runtime_error("mueeZqqH called with a class whose parent is not NPbase");
250}
251
253{
254 return myNPbase->mueeZqqH(sqrt_s);
255}
256
257mueeZqqHPol::mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
258: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
259{
260 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
261 throw std::runtime_error("mueeZqqHPol called with a class whose parent is not NPbase");
262}
263
265{
267}
268
269
270aPsk::aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
271: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
272{
273 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
274 throw std::runtime_error("aPsk called with a class whose parent is not NPbase");
275}
276
278{
280}
281
282
283bPsk::bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
284: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
285{
286 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
287 throw std::runtime_error("bPsk called with a class whose parent is not NPbase");
288}
289
291{
293}
294
295
296muVH::muVH(const StandardModel& SM_i, const double sqrt_s_i)
297: ThObservable(SM_i), sqrt_s(sqrt_s_i)
298{
299 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
300 throw std::runtime_error("muVH called with a class whose parent is not NPbase");
301}
302
304{
305 return myNPbase->muVH(sqrt_s);
306}
307
308muVHpT250::muVHpT250(const StandardModel& SM_i, const double sqrt_s_i)
309: ThObservable(SM_i), sqrt_s(sqrt_s_i)
310{
311 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
312 throw std::runtime_error("muVHpT250 called with a class whose parent is not NPbase");
313}
314
316{
317 return myNPbase->muVHpT250(sqrt_s);
318}
319
320muVBFpVH::muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
321: ThObservable(SM_i), sqrt_s(sqrt_s_i)
322{
323 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
324 throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
325}
326
328{
329 return myNPbase->muVBFpVH(sqrt_s);
330}
331
332muttH::muttH(const StandardModel& SM_i, const double sqrt_s_i)
333: ThObservable(SM_i), sqrt_s(sqrt_s_i)
334{
335 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
336 throw std::runtime_error("muttH called with a class whose parent is not NPbase");
337}
338
340{
341 return myNPbase->muttH(sqrt_s);
342}
343
344mutHq::mutHq(const StandardModel& SM_i, const double sqrt_s_i)
345: ThObservable(SM_i), sqrt_s(sqrt_s_i)
346{
347 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
348 throw std::runtime_error("mutHq called with a class whose parent is not NPbase");
349}
350
352{
353 return myNPbase->mutHq(sqrt_s);
354}
355
356muggHpttH::muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
357: ThObservable(SM_i), sqrt_s(sqrt_s_i)
358{
359 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
360 throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
361}
362
364{
365 return myNPbase->muggHpttH(sqrt_s);
366}
367
368mueettH::mueettH(const StandardModel& SM_i, const double sqrt_s_i)
369: ThObservable(SM_i), sqrt_s(sqrt_s_i)
370{
371 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
372 throw std::runtime_error("mueettH called with a class whose parent is not NPbase");
373
374}
375
377{
378 return myNPbase->mueettH(sqrt_s);
379}
380
381mueettHPol::mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
382: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
383{
384 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
385 throw std::runtime_error("mueettHPol called with a class whose parent is not NPbase");
386}
387
389{
391}
392
393mummH::mummH(const StandardModel& SM_i, const double sqrt_s_i)
394: ThObservable(SM_i), sqrt_s(sqrt_s_i)
395{
396 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
397 throw std::runtime_error("mummH called with a class whose parent is not NPbase");
398}
399
401{
402 return myNPbase->mummH(sqrt_s);
403}
404
405mummHNWA::mummHNWA(const StandardModel& SM_i, const double sqrt_s_i)
406: ThObservable(SM_i), sqrt_s(sqrt_s_i)
407{
408 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
409 throw std::runtime_error("mummHNWA called with a class whose parent is not NPbase");
410}
411
413{
414 return myNPbase->mummHNWA(sqrt_s);
415}
416
418: ThObservable(SM_i)
419{
420 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
421 throw std::runtime_error("GammaHRatio called with a class whose parent is not NPbase");
422}
423
425{
427}
428
430{
431 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
432 throw std::runtime_error("BrHtoinvRatio called with a class whose parent is not NPbase");
433}
434
436{
437 return myNPbase->BrHtoinvRatio();
438}
439
441: ThObservable(SM_i)
442{
443 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
444 throw std::runtime_error("BrHinvisible called with a class whose parent is not NPbase");
445}
446
448{
449 return myNPbase->Br_H_inv();
450}
451
453: ThObservable(SM_i)
454{
455 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
456 throw std::runtime_error("BrHinvisibleNP called with a class whose parent is not NPbase");
457}
458
460{
461 return myNPbase->Br_H_inv_NP();
462}
463
465: ThObservable(SM_i)
466{
467 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
468 throw std::runtime_error("BrHexotic called with a class whose parent is not NPbase");
469}
470
472{
473 return myNPbase->Br_H_exo();
474}
475
477: ThObservable(SM_i)
478{
479 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
480 throw std::runtime_error("BrHtovisRatio called with a class whose parent is not NPbase");
481}
482
484{
485 return myNPbase->BrHvisRatio();
486}
487
489: ThObservable(SM_i)
490{
491 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
492 throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
493}
494
496{
497 return myNPbase->BrHggRatio();
498}
499
501: ThObservable(SM_i)
502{
503 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
504 throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
505}
506
508{
509 return myNPbase->BrHWWRatio();
510}
511
513: ThObservable(SM_i)
514{
515 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
516 throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
517}
518
520{
521 return myNPbase->BrHZZRatio();
522}
523
525: ThObservable(SM_i)
526{
527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
528 throw std::runtime_error("BrHtoVVRatio called with a class whose parent is not NPbase");
529}
530
532{
533 return myNPbase->BrHVVRatio();
534}
535
537{
538 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
539 throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
540}
541
543{
544 return myNPbase->BrHZgaRatio();
545}
546
548{
549 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
550 throw std::runtime_error("BrHtoZgallRatio called with a class whose parent is not NPbase");
551}
552
554{
555 return myNPbase->BrHZgallRatio();
556}
557
559{
560 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
561 throw std::runtime_error("BrHtoZgaeeRatio called with a class whose parent is not NPbase");
562}
563
565{
566 return myNPbase->BrHZgaeeRatio();
567}
568
570{
571 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
572 throw std::runtime_error("BrHtoZgamumuRatio called with a class whose parent is not NPbase");
573}
574
576{
577 return myNPbase->BrHZgamumuRatio();
578}
579
581{
582 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
583 throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
584}
585
587{
588 return myNPbase->BrHgagaRatio();
589}
590
592{
593 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
594 throw std::runtime_error("BrHtomumuRatio called with a class whose parent is not NPbase");
595}
596
598{
599 return myNPbase->BrHmumuRatio();
600}
601
603{
604 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
605 throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
606}
607
609{
610 return myNPbase->BrHtautauRatio();
611}
612
614{
615 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
616 throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
617}
618
620{
621 return myNPbase->BrHccRatio();
622}
623
625{
626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
627 throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
628}
629
631{
632 return myNPbase->BrHbbRatio();
633}
634
635// -----------------------------------------------------------------------------
636// More 4 fermion decays
637// -----------------------------------------------------------------------------
638
639
641: ThObservable(SM_i)
642{
643 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
644 throw std::runtime_error("BrHto2l2vRatio called with a class whose parent is not NPbase");
645}
646
648{
649 return myNPbase->BrH2l2vRatio();
650}
651
652
654: ThObservable(SM_i)
655{
656 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
657 throw std::runtime_error("BrHtoevmuvRatio called with a class whose parent is not NPbase");
658}
659
661{
662 return myNPbase->BrHevmuvRatio();
663}
664
665
667: ThObservable(SM_i)
668{
669 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
670 throw std::runtime_error("BrHto2e2vRatio called with a class whose parent is not NPbase");
671}
672
674{
675 // SM decay widths (from MG simulations)
676 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
677
678 // Sum
679 double wH2e2vTSM=wH2e2vSM+wH2evSM;
680
681 return ( (wH2e2vSM*(myNPbase->BrH2e2vRatio()) + wH2evSM*(myNPbase->BrH2evRatio())) / wH2e2vTSM );
682}
683
684
686: ThObservable(SM_i)
687{
688 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
689 throw std::runtime_error("BrHto2mu2vRatio called with a class whose parent is not NPbase");
690}
691
693{
694 // SM decay widths (from MG simulations)
695 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
696
697 // Sum
698 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
699
700 return ( (wH2mu2vSM*(myNPbase->BrH2mu2vRatio()) + wH2muvSM*(myNPbase->BrH2muvRatio())) / wH2mu2vTSM );
701}
702
703
705: ThObservable(SM_i)
706{
707 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
708 throw std::runtime_error("BrHto4lRatio called with a class whose parent is not NPbase");
709}
710
712{
713 return myNPbase->BrH4lRatio();
714}
715
716
718: ThObservable(SM_i)
719{
720 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
721 throw std::runtime_error("BrHto4eRatio called with a class whose parent is not NPbase");
722}
723
725{
726 return myNPbase->BrH4eRatio();
727}
728
729
731: ThObservable(SM_i)
732{
733 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
734 throw std::runtime_error("BrHto4muRatio called with a class whose parent is not NPbase");
735}
736
738{
739 return myNPbase->BrH4muRatio();
740}
741
742
744: ThObservable(SM_i)
745{
746 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
747 throw std::runtime_error("BrHto2e2muRatio called with a class whose parent is not NPbase");
748}
749
751{
752 return myNPbase->BrH2e2muRatio();
753}
754
755
756
758: ThObservable(SM_i)
759{
760 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
761 throw std::runtime_error("BrHtolljjRatio called with a class whose parent is not NPbase");
762}
763
765{
766 return myNPbase->BrHlljjRatio();
767}
768
769
771: ThObservable(SM_i)
772{
773 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
774 throw std::runtime_error("BrHtolvjjRatio called with a class whose parent is not NPbase");
775}
776
778{
779 return myNPbase->BrHlvjjRatio();
780}
781
782
784: ThObservable(SM_i)
785{
786 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
787 throw std::runtime_error("BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
788}
789
791{
792 return myNPbase->BrHlv_lvorjjRatio();
793}
794
795
797: ThObservable(SM_i)
798{
799 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
800 throw std::runtime_error("BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
801}
802
804{
805 return myNPbase->BrHll_vvorjjRatio();
806}
807
808// -----------------------------------------------------------------------------
809// Ratios of BR (ratios with SM)
810// -----------------------------------------------------------------------------
811
813{
814 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
815 throw std::runtime_error("BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
816}
817
819{
820 if ((this->getModel()).isModelLinearized()) {
821 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHmumuRatio()));
822 } else {
823 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHmumuRatio());
824 }
825}
826
828{
829 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
830 throw std::runtime_error("BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
831}
832
834{
835 if ((this->getModel()).isModelLinearized()) {
836 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHmumuRatio()));
837 } else {
838 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHmumuRatio());
839 }
840}
841
843{
844 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
845 throw std::runtime_error("BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
846}
847
849{
850 if ((this->getModel()).isModelLinearized()) {
851 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrHmumuRatio()));
852 } else {
854 }
855}
856
858{
859 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
860 throw std::runtime_error("BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
861}
862
864{
865 if ((this->getModel()).isModelLinearized()) {
866 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH4lRatio()));
867 } else {
868 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH4lRatio());
869 }
870}
871
873{
874 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
875 throw std::runtime_error("BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
876}
877
879{
880 if ((this->getModel()).isModelLinearized()) {
881 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrH4lRatio()));
882 } else {
883 return (myNPbase->BrHbbRatio()) / (myNPbase->BrH4lRatio());
884 }
885}
886
887
889{
890 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
891 throw std::runtime_error("BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
892}
893
895{
896 if ((this->getModel()).isModelLinearized()) {
897 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrH4lRatio()));
898 } else {
899 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrH4lRatio());
900 }
901}
902
903
905{
906 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
907 throw std::runtime_error("BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
908}
909
911{
912 if ((this->getModel()).isModelLinearized()) {
913 return (1.0 + (myNPbase->BrHtautauRatio()) - (myNPbase->BrH4lRatio()));
914 } else {
915 return (myNPbase->BrHtautauRatio()) / (myNPbase->BrH4lRatio());
916 }
917}
918
919
921{
922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
923 throw std::runtime_error("BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
924}
925
927{
928 if ((this->getModel()).isModelLinearized()) {
929 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH2e2muRatio()));
930 } else {
931 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH2e2muRatio());
932 }
933}
934
936{
937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
938 throw std::runtime_error("BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
939}
940
942{
943 if ((this->getModel()).isModelLinearized()) {
944 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4lRatio()));
945 } else {
946 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4lRatio());
947 }
948}
949
951{
952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
953 throw std::runtime_error("BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
954}
955
957{
958 if ((this->getModel()).isModelLinearized()) {
959 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4lRatio()));
960 } else {
961 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4lRatio());
962 }
963}
964
966{
967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
968 throw std::runtime_error("BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
969}
970
972{
973 if ((this->getModel()).isModelLinearized()) {
974 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4muRatio()));
975 } else {
976 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4muRatio());
977 }
978}
979
981{
982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
983 throw std::runtime_error("BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
984}
985
987{
988 if ((this->getModel()).isModelLinearized()) {
989 return (1.0 + (myNPbase->BrH4lRatio()) - (myNPbase->BrHgagaRatio()));
990 } else {
991 return (myNPbase->BrH4lRatio()) / (myNPbase->BrHgagaRatio());
992 }
993}
994
996{
997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
998 throw std::runtime_error("BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
999}
1000
1002{
1003 if ((this->getModel()).isModelLinearized()) {
1004 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHgagaRatio()));
1005 } else {
1006 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHgagaRatio());
1007 }
1008}
1009
1011{
1012 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1013 throw std::runtime_error("BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1014}
1015
1017{
1018 if ((this->getModel()).isModelLinearized()) {
1019 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrHgagaRatio()));
1020 } else {
1021 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrHgagaRatio());
1022 }
1023}
1024
1025
1027{
1028 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1029 throw std::runtime_error("BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1030}
1031
1033{
1034 if ((this->getModel()).isModelLinearized()) {
1035 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrHgagaRatio()));
1036 } else {
1037 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrHgagaRatio());
1038 }
1039}
1040
1041
1043{
1044 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1045 throw std::runtime_error("BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1046}
1047
1049{
1050 if ((this->getModel()).isModelLinearized()) {
1051 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrHccRatio()));
1052 } else {
1053 return (myNPbase->BrHbbRatio()) / (myNPbase->BrHccRatio());
1054 }
1055}
1056
1057
1059{
1060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1061 throw std::runtime_error("BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1062}
1063
1065{
1066 if ((this->getModel()).isModelLinearized()) {
1067 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHggRatio()));
1068 } else {
1069 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHggRatio());
1070 }
1071}
1072
1073
1075{
1076 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1077 throw std::runtime_error("BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1078}
1079
1081{
1082 if ((this->getModel()).isModelLinearized()) {
1083 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHbbRatio()));
1084 } else {
1085 return (myNPbase->BrHggRatio()) / (myNPbase->BrHbbRatio());
1086 }
1087}
1088
1089
1091{
1092 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1093 throw std::runtime_error("BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1094}
1095
1097{
1098 if ((this->getModel()).isModelLinearized()) {
1099 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHccRatio()));
1100 } else {
1101 return (myNPbase->BrHggRatio()) / (myNPbase->BrHccRatio());
1102 }
1103}
1104
1105
1106// -----------------------------------------------------------------------------
1107// Full signal strengths (prod x decay)
1108// -----------------------------------------------------------------------------
1109
1110muggHgaga::muggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1111: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1112{
1113 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1114 throw std::runtime_error("muggHgaga called with a class whose parent is not NPbase");
1115}
1116
1118{
1119 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1120 //AG: Most general expression including quadratic corrections.
1121 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1122 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1123 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1124 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1125 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1126 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1127
1128 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1129 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1130 double Br1 = dGammaR1-dGammaRTot1;
1131 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1132 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1133 } else {
1134 return myNPbase->muggHgaga(sqrt_s);
1135 }
1136}
1137
1138muggHgagaInt::muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i)
1139: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1140{
1141 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1142 throw std::runtime_error("muggHgagaInt called with a class whose parent is not NPbase");
1143}
1144
1146{
1148}
1149
1150muVBFHgaga::muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1151: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1152{
1153 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1154 throw std::runtime_error("muVBFHgaga called with a class whose parent is not NPbase");
1155}
1156
1158{
1159 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1160 //AG: Most general expression including quadratic corrections.
1161 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1162 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1163 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1164 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1165 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1166 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1167
1168 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1169 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1170 double Br1 = dGammaR1-dGammaRTot1;
1171 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1172
1173 double mu;
1174
1175 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1176
1177 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1178
1179 return mu;
1180 } else {
1181 return myNPbase->muVBFHgaga(sqrt_s);
1182 }
1183}
1184
1185muZHgaga::muZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1187{
1188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1189 throw std::runtime_error("muZHgaga called with a class whose parent is not NPbase");
1190}
1191
1193{
1194 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1195 //AG: Most general expression including quadratic corrections.
1196 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1197 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1198 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1199 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1200 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1201 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1202
1203 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1204 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1205 double Br1 = dGammaR1-dGammaRTot1;
1206 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1207
1208 double mu;
1209
1210 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1211
1212 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1213
1214 return mu;
1215
1216 } else {
1217 return myNPbase->muZHgaga(sqrt_s);
1218 }
1219}
1220
1221muWHgaga::muWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1222: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1223{
1224 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1225 throw std::runtime_error("muWHgaga called with a class whose parent is not NPbase");
1226}
1227
1229{
1230 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1231 //AG: Most general expression including quadratic corrections.
1232 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1233 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1234 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1235 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1236 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1237 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1238
1239 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1240 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1241 double Br1 = dGammaR1-dGammaRTot1;
1242 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1243
1244 double mu;
1245
1246 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1247
1248 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1249
1250 return mu;
1251
1252 } else {
1253 return myNPbase->muWHgaga(sqrt_s);
1254 }
1255}
1256
1257muVHgaga::muVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1258: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1259{
1260 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1261 throw std::runtime_error("muVHgaga called with a class whose parent is not NPbase");
1262}
1263
1265{
1266 if ((this->getModel()).isModelLinearized()) {
1267 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1268 } else {
1269 return myNPbase->muVHgaga(sqrt_s);
1270 }
1271}
1272
1273muttHgaga::muttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1274: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1275{
1276 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1277 throw std::runtime_error("muttHgaga called with a class whose parent is not NPbase");
1278}
1279
1281{
1282 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1283 //AG: Most general expression including quadratic corrections.
1284 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1285 //return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1286 double muProd1 = myNPbase->delta_muttH_1(sqrt_s);
1287 double muProd2 = myNPbase->delta_muttH_2(sqrt_s);
1288 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1289 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1290
1291 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1292 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1293 double Br1 = dGammaR1-dGammaRTot1;
1294 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1295
1296 double mu;
1297
1298 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1299
1300 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1301
1302 return mu;
1303
1304 } else {
1305 return myNPbase->muttHgaga(sqrt_s);
1306 }
1307}
1308
1309mutHgaga::mutHgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1310: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1311{
1312 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1313 throw std::runtime_error("mutHgaga called with a class whose parent is not NPbase");
1314}
1315
1317{
1318 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1319 //AG: Most general expression including quadratic corrections.
1320 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1321 double muProd1 = myNPbase->delta_mutH_1(sqrt_s);
1322 double muProd2 = myNPbase->delta_mutH_2(sqrt_s);
1323 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1324 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1325
1326 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1327 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1328 double Br1 = dGammaR1-dGammaRTot1;
1329 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1330
1331 double mu;
1332
1333 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1334
1335 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1336
1337 return mu;
1338
1339 } else {
1340 //VM: Just in case someone wants to add directly the production*decay
1341 //(which is the observable we fit at the end)
1342 double NPmutHgaga = myNPbase->mutHgaga(sqrt_s);
1343 if(NPmutHgaga==1.0){
1344 return ((myNPbase->mutH(sqrt_s)) )*(myNPbase->BrHgagaRatio());
1345 } else{
1346 return NPmutHgaga;
1347 }
1348 }
1349}
1350
1351muggHpbbH_Hgaga::muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1352: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1353{
1354 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1355 throw std::runtime_error("muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1356}
1357
1359{
1360 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1361 //AG: Most general expression including quadratic corrections.
1362 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1363 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1364 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1365 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1366 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1367
1368 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1369 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1370 double Br1 = dGammaR1-dGammaRTot1;
1371 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1372
1373 double mu;
1374
1375 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1376
1377 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1378
1379 return mu;
1380
1381 } else {
1382 //VM: Just in case someone wants to add directly the production*decay
1383 //(which is the observable we fit at the end)
1384 //Also, the bbH is missing here, I'll leave it as it was for the
1385 //moment (since bbH is really suppressed).
1386 double NPmuggHpbbH_Hgaga = myNPbase->muggHpbbH_Hgaga(sqrt_s);
1387 if (NPmuggHpbbH_Hgaga == 1.0){
1388 return (myNPbase->muggHgaga(sqrt_s));
1389 } else{
1390 return NPmuggHpbbH_Hgaga;
1391 }
1392 }
1393}
1394
1395muttHptH_Hgaga::muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1397{
1398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1399 throw std::runtime_error("muttHptH_Hgaga called with a class whose parent is not NPbase");
1400}
1401
1403{
1404 //VM:Note that these values are valid for 13 TeV, they are not general
1405 //We should access the SM function that has all the values (for the
1406 //different energies). The values are slightly different, we should
1407 //check this.
1408 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1409 double xsSM_ttH = 0.499873;
1410 double xsSM_tH = 0.0821;
1411 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1412 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1413
1414 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1415 //AG: Most general expression including quadratic corrections.
1416 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1417 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1418 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1419 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1420 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1421
1422 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1423 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1424 double Br1 = dGammaR1-dGammaRTot1;
1425 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1426
1427 double mu;
1428
1429 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1430
1431 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1432
1433 return mu;
1434
1435 } else {
1436 //VM: Just in case someone wants to add directly the production*decay
1437 //(which is the observable we fit at the end)
1438 double NPmuttHptH_Hgaga = myNPbase->muttHptH_Hgaga(sqrt_s);
1439 if(NPmuttHptH_Hgaga==1.0){
1440 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHgagaRatio()) ;
1441 } else {
1442 return NPmuttHptH_Hgaga;
1443 }
1444 }
1445}
1446
1447muggHZga::muggHZga(const StandardModel& SM_i, const double sqrt_s_i)
1448: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1449{
1450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1451 throw std::runtime_error("muggHZga called with a class whose parent is not NPbase");
1452}
1453
1455{
1456 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1457 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1458 //AG: Most general expression including quadratic corrections.
1459 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1460 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1461 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1462 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1463 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1464
1465 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1466 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1467 double Br1 = dGammaR1-dGammaRTot1;
1468 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1469
1470 double mu;
1471
1472 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1473
1474 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1475
1476 return mu;
1477
1478 } else {
1479 return myNPbase->muggHZga(sqrt_s);
1480 }
1481}
1482
1483muggHZgamumu::muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
1484: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1485{
1486 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1487 throw std::runtime_error("muggHZgamumu called with a class whose parent is not NPbase");
1488}
1489
1491{
1492 if ((this->getModel()).isModelLinearized()) {
1493 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgamumuRatio()));
1494 } else {
1496 }
1497}
1498
1499muVBFHZga::muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
1500: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1501{
1502 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1503 throw std::runtime_error("muVBFHZga called with a class whose parent is not NPbase");
1504}
1505
1507{
1508 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1509 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1510 //AG: Most general expression including quadratic corrections.
1511 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1512 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1513 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1514 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1515 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1516
1517 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1518 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1519 double Br1 = dGammaR1-dGammaRTot1;
1520 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1521
1522 double mu;
1523
1524 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1525
1526 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1527
1528 return mu;
1529
1530 } else {
1531 return myNPbase->muVBFHZga(sqrt_s);
1532 }
1533}
1534
1535muZHZga::muZHZga(const StandardModel& SM_i, const double sqrt_s_i)
1536: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1537{
1538 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1539 throw std::runtime_error("muZHZga called with a class whose parent is not NPbase");
1540}
1541
1543{
1544 if ((this->getModel()).isModelLinearized()) {
1545 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1546 } else {
1547 return myNPbase->muZHZga(sqrt_s);
1548 }
1549}
1550
1551muWHZga::muWHZga(const StandardModel& SM_i, const double sqrt_s_i)
1552: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1553{
1554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1555 throw std::runtime_error("muWHZga called with a class whose parent is not NPbase");
1556}
1557
1559{
1560 if ((this->getModel()).isModelLinearized()) {
1561 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1562 } else {
1563 return myNPbase->muWHZga(sqrt_s);
1564 }
1565}
1566
1567muVHZga::muVHZga(const StandardModel& SM_i, const double sqrt_s_i)
1568: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1569{
1570 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1571 throw std::runtime_error("muVHZga called with a class whose parent is not NPbase");
1572}
1573
1575{
1576 if ((this->getModel()).isModelLinearized()) {
1577 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1578 } else {
1579 return myNPbase->muVHZga(sqrt_s);
1580 }
1581}
1582
1583muttHZga::muttHZga(const StandardModel& SM_i, const double sqrt_s_i)
1584: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1585{
1586 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1587 throw std::runtime_error("muttHZga called with a class whose parent is not NPbase");
1588}
1589
1591{
1592 if ((this->getModel()).isModelLinearized()) {
1593 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1594 } else {
1595 return myNPbase->muttHZga(sqrt_s);
1596 }
1597}
1598
1599muggHZZ::muggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1600: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1601{
1602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1603 throw std::runtime_error("muggHZZ called with a class whose parent is not NPbase");
1604}
1605
1607{
1608 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1609 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1610 //AG: Most general expression including quadratic corrections.
1611 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1612 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1613 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1614 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1615 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1616
1617 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1618 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1619 double Br1 = dGammaR1-dGammaRTot1;
1620 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1621
1622 double mu;
1623
1624 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1625
1626 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1627
1628 return mu;
1629
1630 } else {
1631 return myNPbase->muggHZZ(sqrt_s);
1632 }
1633}
1634
1635muVBFHZZ::muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1636: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1637{
1638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1639 throw std::runtime_error("muVBFHZZ called with a class whose parent is not NPbase");
1640}
1641
1643{
1644 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1645 //AG: Most general expression including quadratic corrections.
1646 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1647 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZZRatio()));
1648 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1649 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1650 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1651 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1652
1653 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1654 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1655 double Br1 = dGammaR1-dGammaRTot1;
1656 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1657
1658 double mu;
1659
1660 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1661
1662 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1663
1664 return mu;
1665
1666 } else {
1667 return myNPbase->muVBFHZZ(sqrt_s);
1668 }
1669}
1670
1671muZHZZ::muZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1672: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1673{
1674 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1675 throw std::runtime_error("muZHZZ called with a class whose parent is not NPbase");
1676}
1677
1679{
1680 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1681 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1682 //AG: Most general expression including quadratic corrections.
1683 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1684 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1685 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1686 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1687 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1688
1689 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1690 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1691 double Br1 = dGammaR1-dGammaRTot1;
1692 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1693
1694 double mu;
1695
1696 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1697
1698 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1699
1700 return mu;
1701
1702 } else {
1703 return myNPbase->muZHZZ(sqrt_s);
1704 }
1705}
1706
1707muWHZZ::muWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1708: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1709{
1710 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1711 throw std::runtime_error("muWHZZ called with a class whose parent is not NPbase");
1712}
1713
1715{
1716 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1717 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1718 //AG: Most general expression including quadratic corrections.
1719 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1720 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1721 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1722 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1723 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1724
1725 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1726 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1727 double Br1 = dGammaR1-dGammaRTot1;
1728 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1729
1730 double mu;
1731
1732 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1733
1734 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1735
1736 return mu;
1737
1738 } else {
1739 return myNPbase->muWHZZ(sqrt_s);
1740 }
1741}
1742
1743muVHZZ::muVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1744: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1745{
1746 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1747 throw std::runtime_error("muVHZZ called with a class whose parent is not NPbase");
1748}
1749
1751{
1752 //VM:Note that these values are valid for 13 TeV, they are not general
1753 //We should access the SM function that has all the values (for the
1754 //different energies). The values are slightly different, we should
1755 //check this.
1756 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1757 double xsSM_WH = 1.21539;
1758 double xsSM_ZH = 0.795910;
1759 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
1760 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
1761 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1762 //AG: Most general expression including quadratic corrections.
1763 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1764 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1765 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1766 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1767 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1768 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1769
1770 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1771 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1772 double Br1 = dGammaR1-dGammaRTot1;
1773 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1774
1775 double mu;
1776
1777 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1778
1779 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1780
1781 return mu;
1782
1783 } else {
1784 //return myNPbase->muVHZZ(sqrt_s);
1785 //VM: Just in case someone wants to add directly the production*decay
1786 //(which is the observable we fit at the end)
1787 double NPmuVHZZ = myNPbase->muVHZZ(sqrt_s);
1788 if(NPmuVHZZ==1.0){
1789 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHZZRatio());
1790 } else {
1791 return NPmuVHZZ;
1792 }
1793 }
1794}
1795
1796muttHZZ::muttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1797: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1798{
1799 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1800 throw std::runtime_error("muttHZZ called with a class whose parent is not NPbase");
1801}
1802
1804{
1805 if ((this->getModel()).isModelLinearized()) {
1806 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1807 } else {
1808 return myNPbase->muttHZZ(sqrt_s);
1809 }
1810}
1811
1812muttHptH_HZZ::muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1813: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1814{
1815 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1816 throw std::runtime_error("muttHptH_HZZ called with a class whose parent is not NPbase");
1817}
1818
1820{
1821 //VM:Note that these values are valid for 13 TeV, they are not general
1822 //We should access the SM function that has all the values (for the
1823 //different energies). The values are slightly different, we should
1824 //check this.
1825 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1826 double xsSM_ttH = 0.499873;
1827 double xsSM_tH = 0.0821;
1828 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1829 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1830 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1831 //AG: Most general expression including quadratic corrections.
1832 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1833 //return ( 1.0 + muProd1 + (myNPbase->BrHZZRatio()-1.) );
1834 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1835 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1836 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1837 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1838
1839 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1840 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1841 double Br1 = dGammaR1-dGammaRTot1;
1842 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1843
1844 double mu;
1845
1846 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1847
1848 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1849
1850 return mu;
1851
1852 } else {
1853
1854 //VM: Just in case someone wants to add directly the production*decay
1855 //(which is the observable we fit at the end)
1856 double NPmuttHptH_HZZ = myNPbase->muttHptH_HZZ(sqrt_s);
1857 if(NPmuttHptH_HZZ==1.0){
1858 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHZZRatio()) ;
1859 } else {
1860 return NPmuttHptH_HZZ;
1861 }
1862 }
1863}
1864
1865muttHptH_Hmumu::muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1866: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1867{
1868 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1869 throw std::runtime_error("muttHptH_Hmumu called with a class whose parent is not NPbase");
1870}
1871
1873{
1874 //VM:Note that these values are valid for 13 TeV, they are not general
1875 //We should access the SM function that has all the values (for the
1876 //different energies). The values are slightly different, we should
1877 //check this.
1878 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1879 double xsSM_ttH = 0.499873;
1880 double xsSM_tH = 0.0821;
1881 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1882 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1883 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1884 //return ( 1.0
1885 // + ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH)
1886 // + (myNPbase->BrHmumuRatio()-1.));
1887 double muProd1 = ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH);
1888 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1889 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
1890 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
1891
1892 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1893 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1894 double Br1 = dGammaR1-dGammaRTot1;
1895 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1896
1897 double mu;
1898
1899 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1900
1901 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1902
1903 return mu;
1904
1905 } else {
1906
1907 //VM: Just in case someone wants to add directly the production*decay
1908 //(which is the observable we fit at the end)
1909 double NPmuttHptH_Hmumu = myNPbase->muttHptH_Hmumu(sqrt_s);
1910 if(NPmuttHptH_Hmumu==1.0){
1911 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHmumuRatio());
1912 } else {
1913 return NPmuttHptH_Hmumu;
1914 }
1915 }
1916}
1917
1918muggHpbbH_HZZ::muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1919: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1920{
1921 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1922 throw std::runtime_error("muggHpbbH_HZZ called with a class whose parent is not NPbase");
1923}
1924
1926{
1927 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1928 //AG: Most general expression including quadratic corrections.
1929 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1930 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.));
1931 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1932 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1933 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1934 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1935
1936 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1937 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1938 double Br1 = dGammaR1-dGammaRTot1;
1939 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1940
1941 double mu;
1942
1943 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1944
1945 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1946
1947 return mu;
1948
1949 } else {
1950 //VM: Just in case someone wants to add directly the production*decay
1951 //(which is the observable we fit at the end)
1952 //Also, the bbH is missing here, I'll leave it as it was for the
1953 //moment (since bbH is really suppressed in the SM).
1954 double NPmuggHpbbH_HZZ = myNPbase->muggHpbbH_HZZ(sqrt_s);
1955 if (NPmuggHpbbH_HZZ == 1.0){
1956 return (myNPbase->muggHZZ(sqrt_s));
1957 } else{
1958 return NPmuggHpbbH_HZZ;
1959 }
1960 }
1961}
1962
1963muggHZZ4l::muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
1964: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1965{
1966 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1967 throw std::runtime_error("muggHZZ4l called with a class whose parent is not NPbase");
1968}
1969
1971{
1972 if ((this->getModel()).isModelLinearized()) {
1973 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4lRatio()));
1974 } else {
1975 return myNPbase->muggHZZ4l(sqrt_s);
1976 }
1977}
1978
1979muggHZZ4mu::muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
1980: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1981{
1982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1983 throw std::runtime_error("muggHZZ4mu called with a class whose parent is not NPbase");
1984}
1985
1987{
1988 if ((this->getModel()).isModelLinearized()) {
1989 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4muRatio()));
1990 } else {
1991 return (myNPbase->muggH(sqrt_s))*(myNPbase->BrH4muRatio());
1992 }
1993}
1994
1995muVBFHZZ4l::muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
1996: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1997{
1998 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1999 throw std::runtime_error("muVBFHZZ4l called with a class whose parent is not NPbase");
2000}
2001
2003{
2004 if ((this->getModel()).isModelLinearized()) {
2005 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH4lRatio()));
2006 } else {
2007 return myNPbase->muVBFHZZ4l(sqrt_s);
2008 }
2009}
2010
2011muZHZZ4l::muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2012: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2013{
2014 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2015 throw std::runtime_error("muZHZZ4l called with a class whose parent is not NPbase");
2016}
2017
2019{
2020 if ((this->getModel()).isModelLinearized()) {
2021 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2022 } else {
2023 return myNPbase->muZHZZ4l(sqrt_s);
2024 }
2025}
2026
2027muWHZZ4l::muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2028: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2029{
2030 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2031 throw std::runtime_error("muWHZZ4l called with a class whose parent is not NPbase");
2032}
2033
2035{
2036 if ((this->getModel()).isModelLinearized()) {
2037 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2038 } else {
2039 return myNPbase->muWHZZ4l(sqrt_s);
2040 }
2041}
2042
2043muVHZZ4l::muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2044: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2045{
2046 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2047 throw std::runtime_error("muVHZZ4l called with a class whose parent is not NPbase");
2048}
2049
2051{
2052 if ((this->getModel()).isModelLinearized()) {
2053 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2054 } else {
2055 return myNPbase->muVHZZ4l(sqrt_s);
2056 }
2057}
2058
2059muttHZZ4l::muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2060: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2061{
2062 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2063 throw std::runtime_error("muttHZZ4l called with a class whose parent is not NPbase");
2064}
2065
2067{
2068 if ((this->getModel()).isModelLinearized()) {
2069 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2070 } else {
2071 return myNPbase->muttHZZ4l(sqrt_s);
2072 }
2073}
2074
2075muggHWW::muggHWW(const StandardModel& SM_i, const double sqrt_s_i)
2076: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2077{
2078 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2079 throw std::runtime_error("muggHWW called with a class whose parent is not NPbase");
2080}
2081
2083{
2084 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2085 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2086 //AG: Most general expression including quadratic corrections.
2087 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2088 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2089 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2090 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2091 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2092
2093 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2094 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2095 double Br1 = dGammaR1-dGammaRTot1;
2096 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2097
2098 double mu;
2099
2100 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2101
2102 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2103
2104 return mu;
2105
2106 } else {
2107 return myNPbase->muggHWW(sqrt_s);
2108 }
2109}
2110
2111muVBFHWW::muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
2112: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2113{
2114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2115 throw std::runtime_error("muVBFHWW called with a class whose parent is not NPbase");
2116}
2117
2119{
2120 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2121 //AG: Most general expression including quadratic corrections.
2122 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2123 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHWWRatio()));
2124 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2125 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2126 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2127 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2128
2129 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2130 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2131 double Br1 = dGammaR1-dGammaRTot1;
2132 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2133
2134 double mu;
2135
2136 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2137
2138 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2139
2140 return mu;
2141
2142 } else {
2143 return myNPbase->muVBFHWW(sqrt_s);
2144 }
2145}
2146
2147muZHWW::muZHWW(const StandardModel& SM_i, const double sqrt_s_i)
2148: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2149{
2150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2151 throw std::runtime_error("muZHWW called with a class whose parent is not NPbase");
2152}
2153
2155{
2156 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2157 //AG: Most general expression including quadratic corrections.
2158 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2159 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2160 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2161 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2162 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2163 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2164
2165 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2166 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2167 double Br1 = dGammaR1-dGammaRTot1;
2168 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2169
2170 double mu;
2171
2172 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2173
2174 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2175
2176 return mu;
2177
2178 } else {
2179 return myNPbase->muZHWW(sqrt_s);
2180 }
2181}
2182
2183muWHWW::muWHWW(const StandardModel& SM_i, const double sqrt_s_i)
2184: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2185{
2186 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2187 throw std::runtime_error("muWHWW called with a class whose parent is not NPbase");
2188}
2189
2191{
2192 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2193 //AG: Most general expression including quadratic corrections.
2194 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2195 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2196 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2197 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2198 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2199 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2200
2201 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2202 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2203 double Br1 = dGammaR1-dGammaRTot1;
2204 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2205
2206 double mu;
2207
2208 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2209
2210 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2211
2212 return mu;
2213
2214 } else {
2215 return myNPbase->muWHWW(sqrt_s);
2216 }
2217}
2218
2219muVHWW::muVHWW(const StandardModel& SM_i, const double sqrt_s_i)
2220: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2221{
2222 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2223 throw std::runtime_error("muVHWW called with a class whose parent is not NPbase");
2224}
2225
2227{
2228 if ((this->getModel()).isModelLinearized()) {
2229 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2230 } else {
2231 return myNPbase->muVHWW(sqrt_s);
2232 }
2233}
2234
2235muttHWW::muttHWW(const StandardModel& SM_i, const double sqrt_s_i)
2236: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2237{
2238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2239 throw std::runtime_error("muttHWW called with a class whose parent is not NPbase");
2240}
2241
2243{
2244 if ((this->getModel()).isModelLinearized()) {
2245 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2246 } else {
2247 return myNPbase->muttHWW(sqrt_s);
2248 }
2249}
2250
2251muttHptH_HWW::muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2252: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2253{
2254 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2255 throw std::runtime_error("muttHptH_HWW called with a class whose parent is not NPbase");
2256}
2257
2259{
2260
2261 //VM:Note that these values are valid for 13 TeV, they are not general
2262 //We should access the SM function that has all the values (for the
2263 //different energies). The values are slightly different, we should
2264 //check this.
2265 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2266 double xsSM_ttH = 0.499873;
2267 double xsSM_tH = 0.0821;
2268 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2269 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2270 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2271 //AG: Most general expression including quadratic corrections.
2272 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2273 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2274 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2275 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2276 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2277
2278 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2279 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2280 double Br1 = dGammaR1-dGammaRTot1;
2281 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2282
2283 double mu;
2284
2285 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2286
2287 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2288
2289 return mu;
2290
2291 } else {
2292
2293 //VM: Just in case someone wants to add directly the production*decay
2294 //(which is the observable we fit at the end)
2295 double NPmuttHptH_HWW = myNPbase->muttHptH_HWW(sqrt_s);
2296 if(NPmuttHptH_HWW==1.0){
2297 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHWWRatio()) ;
2298 } else {
2299 return NPmuttHptH_HWW;
2300 }
2301 }
2302}
2303
2304muggHpbbH_HWW::muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2305: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2306{
2307 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2308 throw std::runtime_error("muggHpbbH_HWW called with a class whose parent is not NPbase");
2309}
2310
2312{
2313 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2314 //AG: Most general expression including quadratic corrections.
2315 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2316 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.));
2317 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2318 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2319 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2320 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2321
2322 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2323 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2324 double Br1 = dGammaR1-dGammaRTot1;
2325 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2326
2327 double mu;
2328
2329 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2330
2331 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2332
2333 return mu;
2334
2335 } else {
2336
2337 //VM: Just in case someone wants to add directly the production*decay
2338 //(which is the observable we fit at the end)
2339 //Also, the bbH is missing here, I'll leave it as it was for the
2340 //moment (since bbH is really suppressed in the SM).
2341 double NPmuggHpbbH_HWW = myNPbase->muggHpbbH_HWW(sqrt_s);
2342 if (NPmuggHpbbH_HWW == 1.0){
2343 return (myNPbase->muggHWW(sqrt_s));
2344 } else{
2345 return NPmuggHpbbH_HWW;
2346 }
2347 }
2348}
2349
2350muggHWW2l2v::muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2351: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2352{
2353 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2354 throw std::runtime_error("muggHWW2l2v called with a class whose parent is not NPbase");
2355}
2356
2358{
2359 if ((this->getModel()).isModelLinearized()) {
2360 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2361 } else {
2362 return myNPbase->muggHWW2l2v(sqrt_s);
2363 }
2364}
2365
2366muVBFHWW2l2v::muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2367: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2368{
2369 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2370 throw std::runtime_error("muVBFHWW2l2v called with a class whose parent is not NPbase");
2371}
2372
2374{
2375 if ((this->getModel()).isModelLinearized()) {
2376 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2377 } else {
2378 return myNPbase->muVBFHWW2l2v(sqrt_s);
2379 }
2380}
2381
2382muZHWW2l2v::muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2383: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2384{
2385 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2386 throw std::runtime_error("muZHWW2l2v called with a class whose parent is not NPbase");
2387}
2388
2390{
2391 if ((this->getModel()).isModelLinearized()) {
2392 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2393 } else {
2394 return myNPbase->muZHWW2l2v(sqrt_s);
2395 }
2396}
2397
2398muWHWW2l2v::muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2399: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2400{
2401 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2402 throw std::runtime_error("muWHWW2l2v called with a class whose parent is not NPbase");
2403}
2404
2406{
2407 if ((this->getModel()).isModelLinearized()) {
2408 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2409 } else {
2410 return myNPbase->muWHWW2l2v(sqrt_s);
2411 }
2412}
2413
2414muVHWW2l2v::muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2415: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2416{
2417 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2418 throw std::runtime_error("muVHWW2l2v called with a class whose parent is not NPbase");
2419}
2420
2422{
2423 if ((this->getModel()).isModelLinearized()) {
2424 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2425 } else {
2426 return myNPbase->muVHWW2l2v(sqrt_s);
2427 }
2428}
2429
2430muttHWW2l2v::muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2431: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2432{
2433 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2434 throw std::runtime_error("muttHWW2l2v called with a class whose parent is not NPbase");
2435}
2436
2438{
2439 if ((this->getModel()).isModelLinearized()) {
2440 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2441 } else {
2442 return myNPbase->muttHWW2l2v(sqrt_s);
2443 }
2444}
2445
2446muttHVV::muttHVV(const StandardModel& SM_i, const double sqrt_s_i)
2447: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2448{
2449 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2450 throw std::runtime_error("muttHVV called with a class whose parent is not NPbase");
2451}
2452
2454{
2455 if ((this->getModel()).isModelLinearized()) {
2456 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHVVRatio()));
2457 } else {
2458 return (myNPbase->muttH(sqrt_s)) * (myNPbase->BrHVVRatio());
2459 }
2460}
2461
2462muggHmumu::muggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2463: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2464{
2465 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2466 throw std::runtime_error("muggHmumu called with a class whose parent is not NPbase");
2467}
2468
2470{
2471 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2472 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2473 //AG: Most general expression including quadratic corrections.
2474 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2475 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2476 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2477 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2478 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2479
2480 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2481 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2482 double Br1 = dGammaR1-dGammaRTot1;
2483 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2484
2485 double mu;
2486
2487 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2488
2489 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2490
2491 return mu;
2492
2493 } else {
2494 return myNPbase->muggHmumu(sqrt_s);
2495 }
2496}
2497
2498muVBFHmumu::muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2499: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2500{
2501 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2502 throw std::runtime_error("muVBFHmumu called with a class whose parent is not NPbase");
2503}
2504
2506{
2507 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2508 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2509 //AG: Most general expression including quadratic corrections.
2510 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2511 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2512 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2513 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2514 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2515
2516 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2517 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2518 double Br1 = dGammaR1-dGammaRTot1;
2519 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2520
2521 double mu;
2522
2523 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2524
2525 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2526
2527 return mu;
2528
2529 } else {
2530 return myNPbase->muVBFHmumu(sqrt_s);
2531 }
2532}
2533
2534muZHmumu::muZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2535: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2536{
2537 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2538 throw std::runtime_error("muZHmumu called with a class whose parent is not NPbase");
2539}
2540
2542{
2543 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2544 //AG: Most general expression including quadratic corrections.
2545 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2546 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2547 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2548 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2549 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2550
2551 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2552 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2553 double Br1 = dGammaR1-dGammaRTot1;
2554 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2555
2556 double mu;
2557
2558 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2559
2560 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2561
2562 return mu;
2563
2564 } else {
2565 return myNPbase->muZHmumu(sqrt_s);
2566 }
2567}
2568
2569muWHmumu::muWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2570: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2571{
2572 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2573 throw std::runtime_error("muWHmumu called with a class whose parent is not NPbase");
2574}
2575
2577{
2578 if ((this->getModel()).isModelLinearized()) {
2579 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2580 } else {
2581 return myNPbase->muWHmumu(sqrt_s);
2582 }
2583}
2584
2585muVHmumu::muVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2586: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2587{
2588 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2589 throw std::runtime_error("muVHmumu called with a class whose parent is not NPbase");
2590}
2591
2593{
2594
2595 //VM:Note that these values are valid for 13 TeV, they are not general
2596 //We should access the SM function that has all the values (for the
2597 //different energies). The values are slightly different, we should
2598 //check this.
2599 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2600 double xsSM_WH = 1.21539;
2601 double xsSM_ZH = 0.795910;
2602 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2603 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2604 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2605 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2606 //AG: Most general expression including quadratic corrections.
2607 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2608 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2609 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2610 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2611 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2612
2613 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2614 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2615 double Br1 = dGammaR1-dGammaRTot1;
2616 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2617
2618 double mu;
2619
2620 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2621
2622 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2623
2624 return mu;
2625
2626 } else {
2627 //return myNPbase->muVHmumu(sqrt_s);
2628 //VM: Just in case someone wants to add directly the production*decay
2629 //(which is the observable we fit at the end)
2630 double NPmuVHmumu = myNPbase->muVHmumu(sqrt_s);
2631 if(NPmuVHmumu==1.0){
2632 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHmumuRatio());
2633 } else {
2634 return NPmuVHmumu;
2635 }
2636
2637 }
2638}
2639
2640muttHmumu::muttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2641: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2642{
2643 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2644 throw std::runtime_error("muttHmumu called with a class whose parent is not NPbase");
2645}
2646
2648{
2649 if ((this->getModel()).isModelLinearized()) {
2650 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2651 } else {
2652 return myNPbase->muttHmumu(sqrt_s);
2653 }
2654}
2655
2656muggHpttHptHpbbH_Hmumu::muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2657: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2658{
2659 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2660 throw std::runtime_error("muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2661}
2662
2664{
2665 //VM:Note that these values are valid for 13 TeV, they are not general
2666 //We should access the SM function that has all the values (for the
2667 //different energies). The values are slightly different, we should
2668 //check this. Furthermore, the bbH is not included. In the SM this is
2669 //very suppressed (and it's probably also the case in the SMEFT) but
2670 //in some NP models it may not be the case.Unfortunately, bbH is not
2671 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
2672 //SMEFT and add here the general expression.
2673 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2674 double xsSM_ggHbbH = 44.745;
2675 double xsSM_ttH = 0.4998;
2676 double xsSM_tH = 0.084769;
2677 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
2678 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2679 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
2680 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
2681
2682
2683
2684 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2685 //AG: Most general expression including quadratic corrections.
2686 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2687 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2688 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2689 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2690 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2691
2692 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2693 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2694 double Br1 = dGammaR1-dGammaRTot1;
2695 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2696
2697 double mu;
2698
2699 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2700
2701 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2702
2703 return mu;
2704
2705 } else {
2706
2707 //VM: Just in case someone wants to add directly the production*decay
2708 //(which is the observable we fit at the end). Furthermore, the Hbb
2709 //is not added in the original formula, fine for the SM (probably also
2710 //for the SMEFT) but not for all NP models.
2711 double NPmuggHpttHptHpbbH_Hmumu = myNPbase->muggHpttHptHpbbH_Hmumu(sqrt_s);
2712 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2713 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHmumuRatio()) ;
2714 } else {
2715 return NPmuggHpttHptHpbbH_Hmumu;
2716 }
2717 }
2718}
2719
2720muVBFpVH_Hmumu::muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2721: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2722{
2723 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2724 throw std::runtime_error("muVBFpVH_Hmumu called with a class whose parent is not NPbase");
2725}
2726
2728{
2729
2730 //VM:Note that these values are valid for 13 TeV, they are not general
2731 //We should access the SM function that has all the values (for the
2732 //different energies). The values are slightly different, we should
2733 //check this.
2734 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2735 double xsSM_VBF = 3.49948;
2736 double xsSM_WH = 1.21539;
2737 double xsSM_ZH = 0.795910;
2738 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
2739 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2740 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2741 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2742 //AG: Most general expression including quadratic corrections.
2743 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2744 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2745 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2746 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2747 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2748
2749 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2750 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2751 double Br1 = dGammaR1-dGammaRTot1;
2752 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2753
2754 double mu;
2755
2756 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2757
2758 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2759
2760 return mu;
2761
2762 } else {
2763
2764 //VM: Just in case someone wants to add directly the production*decay
2765 //(which is the observable we fit at the end).
2766 double NPmuVBFpVH_Hmumu = myNPbase->muVBFpVH_Hmumu(sqrt_s);
2767 if(NPmuVBFpVH_Hmumu==1.0){
2768 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHmumuRatio()) ;
2769 } else {
2770 return NPmuVBFpVH_Hmumu;
2771 }
2772 }
2773}
2774
2775muggHtautau::muggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2776: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2777{
2778 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2779 throw std::runtime_error("muggHtautau called with a class whose parent is not NPbase");
2780}
2781
2783{
2784 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2785 //AG: Most general expression including quadratic corrections.
2786 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2787 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2788 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2789 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2790 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2791 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2792
2793 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2794 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2795 double Br1 = dGammaR1-dGammaRTot1;
2796 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2797
2798 double mu;
2799
2800 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2801
2802 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2803
2804 return mu;
2805
2806 } else {
2807 return myNPbase->muggHtautau(sqrt_s);
2808 }
2809}
2810
2811muVBFHtautau::muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2812: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2813{
2814 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2815 throw std::runtime_error("muVBFHtautau called with a class whose parent is not NPbase");
2816}
2817
2819{
2820 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2821 //AG: Most general expression including quadratic corrections.
2822 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2823 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2824 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2825 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2826 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2827 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2828
2829 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2830 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2831 double Br1 = dGammaR1-dGammaRTot1;
2832 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2833
2834 double mu;
2835
2836 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2837
2838 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2839
2840 return mu;
2841
2842 } else {
2843 return myNPbase->muVBFHtautau(sqrt_s);
2844 }
2845}
2846
2847
2848
2849muVBFpVHtautau::muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2850: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2851{
2852 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2853 throw std::runtime_error("muVBFpVHtautau called with a class whose parent is not NPbase");
2854}
2855
2857{
2858 if ((this->getModel()).isModelLinearized()) {
2859 return ( -1.0 + (myNPbase->muVBFpVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2860 } else {
2862 }
2863}
2864
2865
2866muZHtautau::muZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2867: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2868{
2869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2870 throw std::runtime_error("muZHtautau called with a class whose parent is not NPbase");
2871}
2872
2873double muZHtautau::computeThValue() //AG:modified
2874{
2875 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2876 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2877 //AG: Most general expression including quadratic corrections.
2878 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2879 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2880 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2881 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2882 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2883 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2884
2885 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2886 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2887 double Br1 = dGammaR1-dGammaRTot1;
2888 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2889
2890 double mu;
2891
2892 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2893
2894 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2895
2896 return mu;
2897
2898 } else {
2899 return myNPbase->muZHtautau(sqrt_s);
2900 }
2901}
2902
2903muWHtautau::muWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2904: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2905{
2906 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2907 throw std::runtime_error("muWHtautau called with a class whose parent is not NPbase");
2908}
2909
2911{
2912 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2913 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2914 //AG: Most general expression including quadratic corrections.
2915 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2916 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2917 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2918 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2919 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2920
2921 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2922 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2923 double Br1 = dGammaR1-dGammaRTot1;
2924 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2925
2926 /*std::cout << "muProd1="<<muProd1<<std::endl;
2927 std::cout << "muProd2="<<muProd2<<std::endl;
2928 std::cout << "dGammaR1="<<dGammaR1<<std::endl;
2929 std::cout << "dGammaR2="<<dGammaR2<<std::endl;
2930 std::cout << "dGammaRTot1="<<dGammaRTot1<<std::endl;
2931 std::cout << "dGammaRTot2="<<dGammaRTot2<<std::endl;
2932
2933 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;
2934 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;*/
2935
2936 double mu;
2937
2938 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2939
2940 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2941
2942 return mu;
2943
2944 } else {
2945 return myNPbase->muWHtautau(sqrt_s);
2946 }
2947}
2948
2949muVHtautau::muVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2950: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2951{
2952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2953 throw std::runtime_error("muVHtautau called with a class whose parent is not NPbase");
2954}
2955
2957{
2958 //VM:Note that these values are valid for 13 TeV, they are not general
2959 //We should access the SM function that has all the values (for the
2960 //different energies). The values are slightly different, we should
2961 //check this.
2962 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2963 double xsSM_WH = 1.21539;
2964 double xsSM_ZH = 0.795910;
2965 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2966 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2967 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2968 //AG: Most general expression including quadratic corrections.
2969 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2970 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2971 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2972 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2973 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2974 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2975
2976 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2977 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2978 double Br1 = dGammaR1-dGammaRTot1;
2979 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2980
2981 double mu;
2982
2983 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2984
2985 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2986
2987 return mu;
2988
2989 } else {
2990 //return myNPbase->muVHtautau(sqrt_s);
2991
2992 //VM: Just in case someone wants to add directly the production*decay
2993 //(which is the observable we fit at the end)
2994 double NPmuVHtautau = myNPbase->muVHtautau(sqrt_s);
2995 if(NPmuVHtautau==1.0){
2996 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHtautauRatio());
2997 } else {
2998 return NPmuVHtautau;
2999 }
3000 }
3001}
3002
3003muttHtautau::muttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3004: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3005{
3006 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3007 throw std::runtime_error("muttHtautau called with a class whose parent is not NPbase");
3008}
3009
3011{
3012 if ((this->getModel()).isModelLinearized()) {
3013 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3014 } else {
3015 return myNPbase->muttHtautau(sqrt_s);
3016 }
3017}
3018
3019muttHptH_Htautau::muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3020: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3021{
3022 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3023 throw std::runtime_error("muttHptH_Htautau called with a class whose parent is not NPbase");
3024}
3025
3027{
3028 //VM:Note that these values are valid for 13 TeV, they are not general
3029 //We should access the SM function that has all the values (for the
3030 //different energies). The values are slightly different, we should
3031 //check this.
3032 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3033 double xsSM_ttH = 0.499873;
3034 double xsSM_tH = 0.0821;
3035 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3036 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3037 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3038 //AG: Most general expression including quadratic corrections.
3039 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3040 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3041 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3042 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3043 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3044
3045 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3046 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3047 double Br1 = dGammaR1-dGammaRTot1;
3048 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3049
3050 double mu;
3051
3052 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3053
3054 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3055
3056 return mu;
3057
3058 } else {
3059
3060 //VM: Just in case someone wants to add directly the production*decay
3061 //(which is the observable we fit at the end)
3062 double NPmuttHptH_Htautau = myNPbase->muttHptH_Htautau(sqrt_s);
3063 if(NPmuttHptH_Htautau==1.0){
3064 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHtautauRatio()) ;
3065 } else {
3066 return NPmuttHptH_Htautau;
3067 }
3068
3069 }
3070}
3071
3072muggHpbbH_Htautau::muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3073: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3074{
3075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3076 throw std::runtime_error("muggHpbbH_Htautau called with a class whose parent is not NPbase");
3077}
3078
3080{
3081 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3082 //AG: Most general expression including quadratic corrections.
3083 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3084 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.));
3085 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3086 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3087 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3088 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3089
3090 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3091 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3092 double Br1 = dGammaR1-dGammaRTot1;
3093 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3094
3095 double mu;
3096
3097 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3098
3099 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3100
3101 return mu;
3102
3103 } else {
3104
3105 //VM: Just in case someone wants to add directly the production*decay
3106 //(which is the observable we fit at the end)
3107 //Also, the bbH is missing here, I'll leave it as it was for the
3108 //moment (since bbH is really suppressed in the SM).
3109 double NPmuggHpbbH_Htautau = myNPbase->muggHpbbH_Htautau(sqrt_s);
3110 if (NPmuggHpbbH_Htautau == 1.0){
3111 return (myNPbase->muggHtautau(sqrt_s));
3112 } else{
3113 return NPmuggHpbbH_Htautau;
3114 }
3115 }
3116}
3117
3118muggHbb::muggHbb(const StandardModel& SM_i, const double sqrt_s_i)
3119: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3120{
3121 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3122 throw std::runtime_error("muggHbb called with a class whose parent is not NPbase");
3123}
3124
3126{
3127 if ((this->getModel()).isModelLinearized()) {
3128 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3129 //AG: Most general expression including quadratic corrections.
3130 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3131 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3132 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3133 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3134 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3135
3136 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3137 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3138 double Br1 = dGammaR1-dGammaRTot1;
3139 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3140
3141 double mu;
3142
3143 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3144
3145 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3146
3147 return mu;
3148
3149 } else {
3150 return myNPbase->muggHbb(sqrt_s);
3151 }
3152}
3153
3154muVBFHbb::muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
3155: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3156{
3157 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3158 throw std::runtime_error("muVBFHbb called with a class whose parent is not NPbase");
3159}
3160
3162{
3163 if ((this->getModel()).isModelLinearized()) {
3164 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHbbRatio()));
3165 } else {
3166 return myNPbase->muVBFHbb(sqrt_s);
3167 }
3168}
3169
3170muZHbb::muZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3171: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3172{
3173 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3174 throw std::runtime_error("muZHbb called with a class whose parent is not NPbase");
3175}
3176
3178{
3179 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3180 //AG: Most general expression including quadratic corrections.
3181 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3182 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3183 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3184 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3185 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3186 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3187
3188 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3189 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3190 double Br1 = dGammaR1-dGammaRTot1;
3191 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3192
3193 double mu;
3194
3195 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3196
3197 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3198
3199 return mu;
3200
3201 } else {
3202 return myNPbase->muZHbb(sqrt_s);
3203 }
3204}
3205
3206muWHbb::muWHbb(const StandardModel& SM_i, const double sqrt_s_i)
3207: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3208{
3209 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3210 throw std::runtime_error("muWHbb called with a class whose parent is not NPbase");
3211}
3212
3214{
3215 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3216 //AG: Most general expression including quadratic corrections.
3217 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3218 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3219 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3220 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3221 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3222 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3223
3224 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3225 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3226 double Br1 = dGammaR1-dGammaRTot1;
3227 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3228
3229 double mu;
3230
3231 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3232
3233 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3234
3235 return mu;
3236
3237 } else {
3238 return myNPbase->muWHbb(sqrt_s);
3239 }
3240}
3241
3242muVHbb::muVHbb(const StandardModel& SM_i, const double sqrt_s_i)
3243: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3244{
3245 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3246 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3247}
3248
3250{
3251 if ((this->getModel()).isModelLinearized()) {
3252 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3253 } else {
3254 return myNPbase->muVHbb(sqrt_s);
3255 }
3256}
3257
3258muttHbb::muttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3259: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3260{
3261 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3262 throw std::runtime_error("muttHbb called with a class whose parent is not NPbase");
3263}
3264
3266{
3267 if ((this->getModel()).isModelLinearized()) {
3268 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3269 } else {
3270 return myNPbase->muttHbb(sqrt_s);
3271 }
3272}
3273
3274muttHptH_Hbb::muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3275: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3276{
3277 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3278 throw std::runtime_error("muttHptH_Hbb called with a class whose parent is not NPbase");
3279}
3280
3282{
3283 //VM:Note that these values are valid for 13 TeV, they are not general
3284 //We should access the SM function that has all the values (for the
3285 //different energies). The values are slightly different, we should
3286 //check this.
3287 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3288 double xsSM_ttH = 0.499873;
3289 double xsSM_tH = 0.0821;
3290 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3291 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3292 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3293 //AG: Most general expression including quadratic corrections.
3294 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3295 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3296 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3297 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3298 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3299
3300 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3301 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3302 double Br1 = dGammaR1-dGammaRTot1;
3303 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3304
3305 double mu;
3306
3307 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3308
3309 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3310
3311 return mu;
3312
3313 } else {
3314
3315
3316 //VM: Just in case someone wants to add directly the production*decay
3317 //(which is the observable we fit at the end)
3318 double NPmuttHptH_Hbb = myNPbase->muttHptH_Hbb(sqrt_s);
3319 if(NPmuttHptH_Hbb==1.0){
3320 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHbbRatio()) ;
3321 } else {
3322 return NPmuttHptH_Hbb;
3323 }
3324 }
3325}
3326
3327muggHpVBFpbbH_Hbb::muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3328: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3329{
3330 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3331 throw std::runtime_error("muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3332}
3333
3335{
3336 //VM:Note that these values are valid for 13 TeV, they are not general
3337 //We should access the SM function that has all the values (for the
3338 //different energies). The values are slightly different, we should
3339 //check this. Furthermore, the bbH is not included. In the SM this is
3340 //very suppressed (and it's probably also the case in the SMEFT) but
3341 //in some NP models it may not be the case.Unfortunately, bbH is not
3342 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
3343 //SMEFT and add here the general expression.
3344 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3345 double xsSM_ggHbbH = 44.745;
3346 double xsSM_VBF = 3.49948;
3347 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
3348 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3349 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
3350 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3351 //AG: Most general expression including quadratic corrections.
3352 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3353 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3354 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3355 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3356 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3357
3358 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3359 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3360 double Br1 = dGammaR1-dGammaRTot1;
3361 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3362
3363 double mu;
3364
3365 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3366
3367 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3368
3369 return mu;
3370
3371 } else {
3372
3373
3374 //VM: Just in case someone wants to add directly the production*decay
3375 //(which is the observable we fit at the end). Furthermore, the Hbb
3376 //is not added in the original formula, fine for the SM (probably also
3377 //for the SMEFT) but not for all NP models.
3378 double NPmuggHpVBFpbbH_Hbb = myNPbase->muggHpVBFpbbH_Hbb(sqrt_s);
3379 if(NPmuggHpVBFpbbH_Hbb==1.0){
3380 return ( xsSM_ggHbbH*(myNPbase->muggH(sqrt_s)) + xsSM_VBF*(myNPbase->muVBF(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF) * (myNPbase->BrHbbRatio()) ;
3381 } else {
3382 return NPmuggHpVBFpbbH_Hbb;
3383 }
3384 }
3385}
3386
3387
3388
3389muVHcc::muVHcc(const StandardModel& SM_i, const double sqrt_s_i)
3390: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3391{
3392 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3393 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3394}
3395
3397{
3398 if ((this->getModel()).isModelLinearized()) {
3399 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHccRatio()));
3400 } else {
3401 return myNPbase->muVHcc(sqrt_s);
3402 }
3403}
3404
3405
3406muVBFBRinv::muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3407: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3408{
3409 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3410 throw std::runtime_error("muVBFBRinv called with a class whose parent is not NPbase");
3411}
3412
3414{
3415
3416 return (myNPbase->muVBF(sqrt_s))*(myNPbase->Br_H_inv());
3417
3418}
3419
3420muVBFHinv::muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
3421: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3422{
3423 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3424 throw std::runtime_error("muVBFHinv called with a class whose parent is not NPbase");
3425}
3426
3428{
3429
3430 if ((this->getModel()).isModelLinearized()) {
3431 return ((myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3432 } else {
3433 return (myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtoinvRatio());
3434 }
3435
3436}
3437
3438
3439muVHBRinv::muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3440: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3441{
3442 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3443 throw std::runtime_error("muVHBRinv called with a class whose parent is not NPbase");
3444}
3445
3447{
3448
3449 return (myNPbase->muVH(sqrt_s))*(myNPbase->Br_H_inv());
3450
3451}
3452
3453muVHinv::muVHinv(const StandardModel& SM_i, const double sqrt_s_i)
3454: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3455{
3456 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3457 throw std::runtime_error("muVHinv called with a class whose parent is not NPbase");
3458}
3459
3461{
3462
3463 if ((this->getModel()).isModelLinearized()) {
3464 return ((myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3465 } else {
3466 return (myNPbase->muVH(sqrt_s))*(myNPbase->BrHtoinvRatio());
3467 }
3468
3469}
3470
3471
3472muppHmumu::muppHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3473: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3474{
3475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3476 throw std::runtime_error("muppHmumu called with a class whose parent is not NPbase");
3477}
3478
3480{
3481 return myNPbase->muppHmumu(sqrt_s);
3482}
3483
3484muppHZga::muppHZga(const StandardModel& SM_i, const double sqrt_s_i)
3485: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3486{
3487 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3488 throw std::runtime_error("muppHZga called with a class whose parent is not NPbase");
3489}
3490
3492{
3493 return myNPbase->muppHZga(sqrt_s);
3494}
3495
3496muggHH2ga2b::muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i)
3497: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3498{
3499 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3500 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
3501}
3502
3504{
3505 if ((this->getModel()).isModelLinearized()) {
3506 return (-2.0 + (myNPbase->muggHH(sqrt_s)) + (myNPbase->BrHgagaRatio()) + (myNPbase->BrHbbRatio()));
3507 } else {
3509 }
3510}
3511
3512muttHZbbboost::muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i)
3513: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3514{
3515 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3516 throw std::runtime_error("muttHZbbboost called with a class whose parent is not NPbase");
3517}
3518
3520{
3521 return (myNPbase->muttHZbbboost(sqrt_s));
3522}
3523
3524//AG:begin
3525ggHgaga::ggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3526: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3527{
3528 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3529 throw std::runtime_error("ggHgaga called with a class whose parent is not NPbase");
3530}
3532{
3533 double SM_prediction = 0.0439; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3534 if ((this->getModel()).isModelLinearized()) {
3535 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3536 } else {
3537 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHgagaRatio());
3538 }
3539}
3540
3541
3542ggHZZ::ggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3543: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3544{
3545 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3546 throw std::runtime_error("ggHZZ called with a class whose parent is not NPbase");
3547}
3549{
3550 double SM_prediction = 0.5197; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3551 if ((this->getModel()).isModelLinearized()) {
3552 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3553 } else {
3554 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHZZRatio());
3555 }
3556}
3557
3558
3559ggHWW::ggHWW(const StandardModel& SM_i, const double sqrt_s_i)
3560: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3561{
3562 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3563 throw std::runtime_error("ggHWW called with a class whose parent is not NPbase");
3564}
3566{
3567 double SM_prediction = 4.1603; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3568 if ((this->getModel()).isModelLinearized()) {
3569 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3570 } else {
3571 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHWWRatio());
3572 }
3573}
3574
3575
3576ggHtautau::ggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3577: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3578{
3579 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3580 throw std::runtime_error("ggHtautau called with a class whose parent is not NPbase");
3581}
3583{
3584 double SM_prediction = 1.2215; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3585 if ((this->getModel()).isModelLinearized()) {
3586 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3587 } else {
3588 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHtautauRatio());
3589 }
3590}
3591
3592
3593VBFHgaga::VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3594: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3595{
3596 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3597 throw std::runtime_error("VBFHgaga called with a class whose parent is not NPbase");
3598}
3600{
3601 double SM_prediction = 0.0037; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3602 if ((this->getModel()).isModelLinearized()) {
3603 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3604 } else {
3605 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHgagaRatio());
3606 }
3607}
3608
3609
3610VBFHZZ::VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3611: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3612{
3613 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3614 throw std::runtime_error("VBFHZZ called with a class whose parent is not NPbase");
3615}
3617{
3618 double SM_prediction = 0.0530; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3619 if ((this->getModel()).isModelLinearized()) {
3620 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3621 } else {
3622 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHZZRatio());
3623 }
3624}
3625
3626
3627VBFHWW::VBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
3628: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3629{
3630 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3631 throw std::runtime_error("VBFHWW called with a class whose parent is not NPbase");
3632}
3634{
3635 double SM_prediction = 0.3494; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3636 if ((this->getModel()).isModelLinearized()) {
3637 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3638 } else {
3639 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHWWRatio());
3640 }
3641}
3642
3643
3644VBFHtautau::VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3645: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3646{
3647 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3648 throw std::runtime_error("VBFHtautau called with a class whose parent is not NPbase");
3649}
3651{
3652 double SM_prediction = 0.1011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3653 if ((this->getModel()).isModelLinearized()) {
3654 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3655 } else {
3656 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtautauRatio());
3657 }
3658}
3659
3660
3661WHgaga::WHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3662: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3663{
3664 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3665 throw std::runtime_error("WHgaga called with a class whose parent is not NPbase");
3666}
3668{
3669 double SM_prediction = 0.0017; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3670 if ((this->getModel()).isModelLinearized()) {
3671 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3672 } else {
3673 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHgagaRatio());
3674 }
3675}
3676
3677
3678WHWW::WHWW(const StandardModel& SM_i, const double sqrt_s_i)
3679: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3680{
3681 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3682 throw std::runtime_error("WHWW called with a class whose parent is not NPbase");
3683}
3685{
3686 double SM_prediction = 0.1614; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3687 if ((this->getModel()).isModelLinearized()) {
3688 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3689 } else {
3690 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHWWRatio());
3691 }
3692}
3693
3694
3695WHtautau::WHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3696: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3697{
3698 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3699 throw std::runtime_error("WWHtautau called with a class whose parent is not NPbase");
3700}
3702{
3703 double SM_prediction = 0.0462; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3704 if ((this->getModel()).isModelLinearized()) {
3705 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3706 } else {
3707 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHtautauRatio());
3708 }
3709}
3710
3711
3712WHbb::WHbb(const StandardModel& SM_i, const double sqrt_s_i)
3713: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3714{
3715 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3716 throw std::runtime_error("WHbb called with a class whose parent is not NPbase");
3717}
3719{
3720 double SM_prediction = 0.4090; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3721 if ((this->getModel()).isModelLinearized()) {
3722 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3723 } else {
3724 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHbbRatio());
3725 }
3726}
3727
3728
3729ZHgaga::ZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3730: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3731{
3732 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3733 throw std::runtime_error("ZHgaga called with a class whose parent is not NPbase");
3734}
3736{
3737 double SM_prediction = 0.0011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3738 if ((this->getModel()).isModelLinearized()) {
3739 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3740 } else {
3741 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHgagaRatio());
3742 }
3743}
3744
3745
3746ZHWW::ZHWW(const StandardModel& SM_i, const double sqrt_s_i)
3747: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3748{
3749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3750 throw std::runtime_error("ZHWW called with a class whose parent is not NPbase");
3751}
3753{
3754 double SM_prediction = 0.0996; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3755 if ((this->getModel()).isModelLinearized()) {
3756 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3757 } else {
3758 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHWWRatio());
3759 }
3760}
3761
3762
3763ZHtautau::ZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3764: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3765{
3766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3767 throw std::runtime_error("ZHtautau called with a class whose parent is not NPbase");
3768}
3770{
3771 double SM_prediction = 0.0304; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3772 if ((this->getModel()).isModelLinearized()) {
3773 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3774 } else {
3775 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHtautauRatio());
3776 }
3777}
3778
3779
3780ZHbb::ZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3781: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3782{
3783 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3784 throw std::runtime_error("ZHbb called with a class whose parent is not NPbase");
3785}
3787{
3788 double SM_prediction = 0.2410; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3789 if ((this->getModel()).isModelLinearized()) {
3790 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3791 } else {
3792 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHbbRatio());
3793 }
3794}
3795
3796
3797ttHgaga::ttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3798: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3799{
3800 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3801 throw std::runtime_error("ttHgaga called with a class whose parent is not NPbase");
3802}
3804{
3805 double SM_prediction = 0.0004; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3806 if ((this->getModel()).isModelLinearized()) {
3807 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3808 } else {
3809 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHgagaRatio());
3810 }
3811}
3812
3813
3814ttHWW::ttHWW(const StandardModel& SM_i, const double sqrt_s_i)
3815: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3816{
3817 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3818 throw std::runtime_error("ttHWW called with a class whose parent is not NPbase");
3819}
3821{
3822 double SM_prediction = 0.0281; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3823 if ((this->getModel()).isModelLinearized()) {
3824 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3825 } else {
3826 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHWWRatio());
3827 }
3828}
3829
3830
3831ttHtautau::ttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3832: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3833{
3834 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3835 throw std::runtime_error("ttHtautau called with a class whose parent is not NPbase");
3836}
3838{
3839 double SM_prediction = 0.0106; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3840 if ((this->getModel()).isModelLinearized()) {
3841 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3842 } else {
3843 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHtautauRatio());
3844 }
3845}
3846
3847
3848ttHbb::ttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3849: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3850{
3851 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3852 throw std::runtime_error("ttHbb called with a class whose parent is not NPbase");
3853}
3855{
3856 double SM_prediction = 0.0751; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3857 if ((this->getModel()).isModelLinearized()) {
3858 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3859 } else {
3860 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHbbRatio());
3861 }
3862}
3863
3864//AG:end
3865
3866UpperLimit_ppHZgammaA::UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3867{
3868 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3869 throw std::runtime_error("UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
3870}
3871
3873{
3875}
3876
3877UpperLimit_ppHZgammaA13::UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3878{
3879 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3880 throw std::runtime_error("UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
3881}
3882
3884{
3886}
3887
3888UpperLimit_ppHZgammaC13::UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3889{
3890 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3891 throw std::runtime_error("UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
3892}
3893
3895{
3897}
3898
3899UpperLimit_ppHZgammaC::UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3900{
3901 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3902 throw std::runtime_error("UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
3903}
3904
3906{
3908}
3909
3911{
3912 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3913 throw std::runtime_error("cg_plus_ct called with a class whose parent is not NPbase");
3914}
3915
3917{
3918 return myNPbase->cgplusct();
3919}
3920
3922{
3923 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3924 throw std::runtime_error("cga_plus_ct called with a class whose parent is not NPbase");
3925}
3926
3928{
3929 return myNPbase->cgaplusct();
3930}
3931
3933{
3934 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3935 throw std::runtime_error("cg_minus_cga called with a class whose parent is not NPbase");
3936}
3937
3939{
3940 return myNPbase->cgminuscga();
3941}
3942
3944{
3945 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3946 throw std::runtime_error("cV_plus_cb called with a class whose parent is not NPbase");
3947}
3948\
3949
3950
3952{
3953 return myNPbase->cVpluscb();
3954}
3955
3957{
3958 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3959 throw std::runtime_error("cV_plus_ctau called with a class whose parent is not NPbase");
3960}
3961
3963{
3964 return myNPbase->cVplusctau();
3965}
3966
3968{
3969 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3970 throw std::runtime_error("cb_minus_cc called with a class whose parent is not NPbase");
3971}
3972
3974{
3975 return myNPbase->cbminuscc();
3976}
3977
3979{
3980 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3981 throw std::runtime_error("cb_minus_ctau called with a class whose parent is not NPbase");
3982}
3983
3985{
3986 return myNPbase->cbminusctau();
3987}
3988
3990{
3991 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3992 throw std::runtime_error("cc_minus_ctau called with a class whose parent is not NPbase");
3993}
3994
3996{
3997 return myNPbase->ccminusctau();
3998}
3999
4000
4001// Full signal strengths at e+ e- colliders
4002// ----------------------------------------
4003
4004mueeZHbb::mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i)
4005: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4006{
4007 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4008 throw std::runtime_error("mueeZHbb called with a class whose parent is not NPbase");
4009}
4010
4012{
4013 if ((this->getModel()).isModelLinearized()) {
4014 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4015 } else {
4016 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHbbRatio());
4017 }
4018}
4019
4020mueeZHcc::mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i)
4021: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4022{
4023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4024 throw std::runtime_error("mueeZHcc called with a class whose parent is not NPbase");
4025}
4026
4028{
4029 if ((this->getModel()).isModelLinearized()) {
4030 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4031 } else {
4032 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHccRatio());
4033 }
4034}
4035
4036mueeZHss::mueeZHss(const StandardModel& SM_i, const double sqrt_s_i)
4037: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4038{
4039 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4040 throw std::runtime_error("mueeZHss called with a class whose parent is not NPbase");
4041}
4042
4044{
4045 if ((this->getModel()).isModelLinearized()) {
4046 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHssRatio()) - 1.0);
4047 } else {
4048 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHssRatio());
4049 }
4050}
4051
4052mueeZHgg::mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i)
4053: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4054{
4055 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4056 throw std::runtime_error("mueeZHgg called with a class whose parent is not NPbase");
4057}
4058
4060{
4061 if ((this->getModel()).isModelLinearized()) {
4062 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4063 } else {
4064 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHggRatio());
4065 }
4066}
4067
4068mueeZHWW::mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i)
4069: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4070{
4071 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4072 throw std::runtime_error("mueeZHWW called with a class whose parent is not NPbase");
4073}
4074
4076{
4077 if ((this->getModel()).isModelLinearized()) {
4078 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4079 } else {
4080 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHWWRatio());
4081 }
4082}
4083
4084mueeZHtautau::mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
4085: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4086{
4087 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4088 throw std::runtime_error("mueeZHtautau called with a class whose parent is not NPbase");
4089}
4090
4092{
4093 if ((this->getModel()).isModelLinearized()) {
4094 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4095 } else {
4097 }
4098}
4099
4100mueeZHZZ::mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
4101: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4102{
4103 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4104 throw std::runtime_error("mueeZHZZ called with a class whose parent is not NPbase");
4105}
4106
4108{
4109 if ((this->getModel()).isModelLinearized()) {
4110 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4111 } else {
4112 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHZZRatio());
4113 }
4114}
4115
4116mueeZHZga::mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i)
4117: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4118{
4119 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4120 throw std::runtime_error("mueeZHZga called with a class whose parent is not NPbase");
4121}
4122
4124{
4125 if ((this->getModel()).isModelLinearized()) {
4126 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4127 } else {
4128 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHZgaRatio());
4129 }
4130}
4131
4132mueeZHgaga::mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
4133: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4134{
4135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4136 throw std::runtime_error("mueeZHgaga called with a class whose parent is not NPbase");
4137}
4138
4140{
4141 if ((this->getModel()).isModelLinearized()) {
4142 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4143 } else {
4144 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHgagaRatio());
4145 }
4146}
4147
4148mueeZHmumu::mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
4149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4150{
4151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4152 throw std::runtime_error("mueeZHmumu called with a class whose parent is not NPbase");
4153}
4154
4156{
4157 if ((this->getModel()).isModelLinearized()) {
4158 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4159 } else {
4160 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHmumuRatio());
4161 }
4162}
4163
4164mueeZHBRinv::mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
4165: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4166{
4167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4168 throw std::runtime_error("mueeZHBRinv called with a class whose parent is not NPbase");
4169}
4170
4172{
4173
4174 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->Br_H_inv());
4175
4176}
4177
4178mueeZHinv::mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i)
4179: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4180{
4181 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4182 throw std::runtime_error("mueeZHinv called with a class whose parent is not NPbase");
4183}
4184
4186{
4187
4188 if ((this->getModel()).isModelLinearized()) {
4189 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
4190 } else {
4192 }
4193
4194}
4195
4196mueeZHbbPol::mueeZHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4197: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4198{
4199 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4200 throw std::runtime_error("mueeZHbbPol called with a class whose parent is not NPbase");
4201}
4202
4204{
4205 if ((this->getModel()).isModelLinearized()) {
4206 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4207 } else {
4209 }
4210}
4211
4212mueeZHccPol::mueeZHccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4213: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4214{
4215 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4216 throw std::runtime_error("mueeZHccPol called with a class whose parent is not NPbase");
4217}
4218
4220{
4221 if ((this->getModel()).isModelLinearized()) {
4222 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4223 } else {
4225 }
4226}
4227
4228mueeZHssPol::mueeZHssPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4229: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4230{
4231 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4232 throw std::runtime_error("mueeZHssPol called with a class whose parent is not NPbase");
4233}
4234
4236{
4237 if ((this->getModel()).isModelLinearized()) {
4238 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHssRatio()) - 1.0);
4239 } else {
4241 }
4242}
4243
4244mueeZHggPol::mueeZHggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4245: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4246{
4247 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4248 throw std::runtime_error("mueeZHggPol called with a class whose parent is not NPbase");
4249}
4250
4252{
4253 if ((this->getModel()).isModelLinearized()) {
4254 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4255 } else {
4257 }
4258}
4259
4260mueeZHWWPol::mueeZHWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4261: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4262{
4263 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4264 throw std::runtime_error("mueeZHWWPol called with a class whose parent is not NPbase");
4265}
4266
4268{
4269 if ((this->getModel()).isModelLinearized()) {
4270 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4271 } else {
4273 }
4274}
4275
4276mueeZHtautauPol::mueeZHtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4277: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4278{
4279 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4280 throw std::runtime_error("mueeZHtautauPol called with a class whose parent is not NPbase");
4281}
4282
4284{
4285 if ((this->getModel()).isModelLinearized()) {
4286 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4287 } else {
4289 }
4290}
4291
4292mueeZHZZPol::mueeZHZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4293: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4294{
4295 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4296 throw std::runtime_error("mueeZHZZPol called with a class whose parent is not NPbase");
4297}
4298
4300{
4301 if ((this->getModel()).isModelLinearized()) {
4302 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4303 } else {
4305 }
4306}
4307
4308mueeZHZgaPol::mueeZHZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4309: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4310{
4311 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4312 throw std::runtime_error("mueeZHZgaPol called with a class whose parent is not NPbase");
4313}
4314
4316{
4317 if ((this->getModel()).isModelLinearized()) {
4318 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4319 } else {
4321 }
4322}
4323
4324mueeZHgagaPol::mueeZHgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4325: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4326{
4327 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4328 throw std::runtime_error("mueeZHgagaPol called with a class whose parent is not NPbase");
4329}
4330
4332{
4333 if ((this->getModel()).isModelLinearized()) {
4334 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4335 } else {
4337 }
4338}
4339
4340mueeZHmumuPol::mueeZHmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4341: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4342{
4343 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4344 throw std::runtime_error("mueeZHmumuPol called with a class whose parent is not NPbase");
4345}
4346
4348{
4349 if ((this->getModel()).isModelLinearized()) {
4350 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4351 } else {
4353 }
4354}
4355
4356mueeZHBRinvPol::mueeZHBRinvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4357: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4358{
4359 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4360 throw std::runtime_error("mueeZHBRinvPol called with a class whose parent is not NPbase");
4361}
4362
4364{
4366
4367}
4368
4369mueeZHinvPol::mueeZHinvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4370: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4371{
4372 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4373 throw std::runtime_error("mueeZHinvPol called with a class whose parent is not NPbase");
4374}
4375
4377{
4378
4379 if ((this->getModel()).isModelLinearized()) {
4380 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtoinvRatio()) - 1.0);
4381 } else {
4383 }
4384
4385}
4386
4387mueeWBFbb::mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4388: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4389{
4390 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4391 throw std::runtime_error("mueeWBFbb called with a class whose parent is not NPbase");
4392
4393}
4394
4396{
4397 if ((this->getModel()).isModelLinearized()) {
4398 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4399 } else {
4400 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHbbRatio());
4401 }
4402}
4403
4404mueeWBFbbPol::mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4405: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4406{
4407 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4408 throw std::runtime_error("mueeWBFbbPol called with a class whose parent is not NPbase");
4409
4410}
4411
4413{
4414 if ((this->getModel()).isModelLinearized()) {
4415 return ((myNPbase->mueeWBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4416 } else {
4418 }
4419}
4420
4421mueeWBFcc::mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
4422: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4423{
4424 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4425 throw std::runtime_error("mueeWBFcc called with a class whose parent is not NPbase");
4426
4427}
4428
4430{
4431 if ((this->getModel()).isModelLinearized()) {
4432 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4433 } else {
4434 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHccRatio());
4435 }
4436}
4437
4438mueeWBFgg::mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
4439: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4440{
4441 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4442 throw std::runtime_error("mueeWBFgg called with a class whose parent is not NPbase");
4443
4444}
4445
4447{
4448 if ((this->getModel()).isModelLinearized()) {
4449 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4450 } else {
4451 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHggRatio());
4452 }
4453}
4454
4455mueeWBFWW::mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i)
4456: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4457{
4458 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4459 throw std::runtime_error("mueeWBFWW called with a class whose parent is not NPbase");
4460
4461}
4462
4464{
4465 if ((this->getModel()).isModelLinearized()) {
4466 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4467 } else {
4468 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHWWRatio());
4469 }
4470}
4471
4472mueeWBFtautau::mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
4473: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4474{
4475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4476 throw std::runtime_error("mueeWBFtautau called with a class whose parent is not NPbase");
4477
4478}
4479
4481{
4482 if ((this->getModel()).isModelLinearized()) {
4483 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4484 } else {
4486 }
4487}
4488
4489mueeWBFZZ::mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i)
4490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4491{
4492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4493 throw std::runtime_error("mueeWBFZZ called with a class whose parent is not NPbase");
4494
4495}
4496
4498{
4499 if ((this->getModel()).isModelLinearized()) {
4500 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4501 } else {
4502 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZZRatio());
4503 }
4504}
4505
4506mueeWBFZga::mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i)
4507: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4508{
4509 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4510 throw std::runtime_error("mueeWBFZga called with a class whose parent is not NPbase");
4511
4512}
4513
4515{
4516 if ((this->getModel()).isModelLinearized()) {
4517 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4518 } else {
4519 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZgaRatio());
4520 }
4521}
4522
4523mueeWBFgaga::mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
4524: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4525{
4526 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4527 throw std::runtime_error("mueeWBFgaga called with a class whose parent is not NPbase");
4528
4529}
4530
4532{
4533 if ((this->getModel()).isModelLinearized()) {
4534 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4535 } else {
4537 }
4538}
4539
4540mueeWBFmumu::mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i)
4541: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4542{
4543 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4544 throw std::runtime_error("mueeWBFmumu called with a class whose parent is not NPbase");
4545
4546}
4547
4549{
4550 if ((this->getModel()).isModelLinearized()) {
4551 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4552 } else {
4554 }
4555}
4556
4557mueeHvvbb::mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4558: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4559{
4560 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4561 throw std::runtime_error("mueeHvvbb called with a class whose parent is not NPbase");
4562
4563}
4564
4566{
4567 if ((this->getModel()).isModelLinearized()) {
4568 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4569 } else {
4570 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4571 }
4572}
4573
4574mueeHvvbbPol::mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4575: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4576{
4577 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4578 throw std::runtime_error("mueeHvvbbPol called with a class whose parent is not NPbase");
4579
4580}
4581
4583{
4584 if ((this->getModel()).isModelLinearized()) {
4585 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4586 } else {
4588 }
4589}
4590
4591mueeHvvcc::mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4592: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4593{
4594 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4595 throw std::runtime_error("mueeHvvcc called with a class whose parent is not NPbase");
4596
4597}
4598
4600{
4601 if ((this->getModel()).isModelLinearized()) {
4602 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4603 } else {
4604 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHccRatio());
4605 }
4606}
4607
4608mueeHvvccPol::mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4609: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4610{
4611 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4612 throw std::runtime_error("mueeHvvccPol called with a class whose parent is not NPbase");
4613
4614}
4615
4617{
4618 if ((this->getModel()).isModelLinearized()) {
4619 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4620 } else {
4622 }
4623}
4624
4625mueeHvvgg::mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4626: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4627{
4628 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4629 throw std::runtime_error("mueeHvvgg called with a class whose parent is not NPbase");
4630
4631}
4632
4634{
4635 if ((this->getModel()).isModelLinearized()) {
4636 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4637 } else {
4638 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHggRatio());
4639 }
4640}
4641
4642mueeHvvggPol::mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4643: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4644{
4645 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4646 throw std::runtime_error("mueeHvvggPol called with a class whose parent is not NPbase");
4647
4648}
4649
4651{
4652 if ((this->getModel()).isModelLinearized()) {
4653 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4654 } else {
4656 }
4657}
4658
4659mueeHvvWW::mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4660: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4661{
4662 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4663 throw std::runtime_error("mueeHvvWW called with a class whose parent is not NPbase");
4664
4665}
4666
4668{
4669 if ((this->getModel()).isModelLinearized()) {
4670 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4671 } else {
4672 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHWWRatio());
4673 }
4674}
4675
4676mueeHvvWWPol::mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4677: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4678{
4679 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4680 throw std::runtime_error("mueeHvvWWPol called with a class whose parent is not NPbase");
4681
4682}
4683
4685{
4686 if ((this->getModel()).isModelLinearized()) {
4687 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4688 } else {
4690 }
4691}
4692
4693mueeHvvtautau::mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
4694: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4695{
4696 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4697 throw std::runtime_error("mueeHvvtautau called with a class whose parent is not NPbase");
4698
4699}
4700
4702{
4703 if ((this->getModel()).isModelLinearized()) {
4704 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4705 } else {
4707 }
4708}
4709
4710mueeHvvtautauPol::mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4711: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4712{
4713 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4714 throw std::runtime_error("mueeHvvtautauPol called with a class whose parent is not NPbase");
4715
4716}
4717
4719{
4720 if ((this->getModel()).isModelLinearized()) {
4721 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4722 } else {
4724 }
4725}
4726
4727mueeHvvZZ::mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
4728: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4729{
4730 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4731 throw std::runtime_error("mueeHvvZZ called with a class whose parent is not NPbase");
4732
4733}
4734
4736{
4737 if ((this->getModel()).isModelLinearized()) {
4738 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4739 } else {
4740 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZZRatio());
4741 }
4742}
4743
4744mueeHvvZZPol::mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4745: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4746{
4747 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4748 throw std::runtime_error("mueeHvvZZPol called with a class whose parent is not NPbase");
4749
4750}
4751
4753{
4754 if ((this->getModel()).isModelLinearized()) {
4755 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4756 } else {
4758 }
4759}
4760
4761mueeHvvZga::mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
4762: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4763{
4764 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4765 throw std::runtime_error("mueeHvvZga called with a class whose parent is not NPbase");
4766
4767}
4768
4770{
4771 if ((this->getModel()).isModelLinearized()) {
4772 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4773 } else {
4774 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
4775 }
4776}
4777
4778mueeHvvZgaPol::mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4779: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4780{
4781 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4782 throw std::runtime_error("mueeHvvZgaPol called with a class whose parent is not NPbase");
4783
4784}
4785
4787{
4788 if ((this->getModel()).isModelLinearized()) {
4789 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4790 } else {
4792 }
4793}
4794
4795mueeHvvgaga::mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
4796: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4797{
4798 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4799 throw std::runtime_error("mueeHvvgaga called with a class whose parent is not NPbase");
4800
4801}
4802
4804{
4805 if ((this->getModel()).isModelLinearized()) {
4806 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4807 } else {
4809 }
4810}
4811
4812mueeHvvgagaPol::mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4813: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4814{
4815 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4816 throw std::runtime_error("mueeHvvgagaPol called with a class whose parent is not NPbase");
4817
4818}
4819
4821{
4822 if ((this->getModel()).isModelLinearized()) {
4823 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4824 } else {
4826 }
4827}
4828
4829mueeHvvmumu::mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
4830: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4831{
4832 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4833 throw std::runtime_error("mueeHvvmumu called with a class whose parent is not NPbase");
4834
4835}
4836
4838{
4839 if ((this->getModel()).isModelLinearized()) {
4840 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4841 } else {
4843 }
4844}
4845
4846mueeHvvmumuPol::mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4847: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4848{
4849 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4850 throw std::runtime_error("mueeHvvmumuPol called with a class whose parent is not NPbase");
4851
4852}
4853
4855{
4856 if ((this->getModel()).isModelLinearized()) {
4857 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4858 } else {
4860 }
4861}
4862
4863mueeZBFbb::mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4864: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4865{
4866 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4867 throw std::runtime_error("mueeZBFbb called with a class whose parent is not NPbase");
4868}
4869
4871{
4872 if ((this->getModel()).isModelLinearized()) {
4873 return ((myNPbase->mueeZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4874 } else {
4875 return (myNPbase->mueeZBF(sqrt_s))*(myNPbase->BrHbbRatio());
4876 }
4877}
4878
4879mueeZBFbbPol::mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4880: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4881{
4882 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4883 throw std::runtime_error("mueeZBFbbPol called with a class whose parent is not NPbase");
4884}
4885
4887{
4888 if ((this->getModel()).isModelLinearized()) {
4889 return ((myNPbase->mueeZBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4890 } else {
4892 }
4893}
4894
4895mueettHbb::mueettHbb(const StandardModel& SM_i, const double sqrt_s_i)
4896: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4897{
4898 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4899 throw std::runtime_error("mueettHbb called with a class whose parent is not NPbase");
4900}
4901
4903{
4904 if ((this->getModel()).isModelLinearized()) {
4905 return ((myNPbase->mueettH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4906 } else {
4907 return (myNPbase->mueettH(sqrt_s))*(myNPbase->BrHbbRatio());
4908 }
4909}
4910
4911mueettHbbPol::mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4912: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4913{
4914 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4915 throw std::runtime_error("mueettHbbPol called with a class whose parent is not NPbase");
4916}
4917
4919{
4920 if ((this->getModel()).isModelLinearized()) {
4921 return ((myNPbase->mueettHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4922 } else {
4924 }
4925}
4926
4927
4928// Production signal strengths at mu+ mu- colliders
4929// ------------------------------------------------
4930
4931mummZH::mummZH(const StandardModel& SM_i, const double sqrt_s_i)
4932: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4933{
4934 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4935 throw std::runtime_error("mummZH called with a class whose parent is not NPbase");
4936}
4937
4939{
4940 return myNPbase->mummZH(sqrt_s);
4941}
4942
4943
4944mummHvv::mummHvv(const StandardModel& SM_i, const double sqrt_s_i)
4945: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4946{
4947 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4948 throw std::runtime_error("mummHvv called with a class whose parent is not NPbase");
4949}
4950
4952{
4953 return myNPbase->mummHvv(sqrt_s);
4954}
4955
4956
4957mummttH::mummttH(const StandardModel& SM_i, const double sqrt_s_i)
4958: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4959{
4960 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4961 throw std::runtime_error("mummttH called with a class whose parent is not NPbase");
4962}
4963
4965{
4966 return myNPbase->mummttH(sqrt_s);
4967}
4968
4969
4970// Full signal strengths at mu+ mu- colliders
4971// -------------------------------------------
4972
4973
4974mummHbb::mummHbb(const StandardModel& SM_i, const double sqrt_s_i)
4975: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4976{
4977 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4978 throw std::runtime_error("mummHbb called with a class whose parent is not NPbase");
4979}
4980
4982{
4983 if ((this->getModel()).isModelLinearized()) {
4984 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4985 } else {
4986 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHbbRatio());
4987 }
4988}
4989
4990mummHcc::mummHcc(const StandardModel& SM_i, const double sqrt_s_i)
4991: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4992{
4993 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4994 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
4995}
4996
4998{
4999 if ((this->getModel()).isModelLinearized()) {
5000 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5001 } else {
5002 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHccRatio());
5003 }
5004}
5005
5006mummHgg::mummHgg(const StandardModel& SM_i, const double sqrt_s_i)
5007: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5008{
5009 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5010 throw std::runtime_error("mummHgg called with a class whose parent is not NPbase");
5011}
5012
5014{
5015 if ((this->getModel()).isModelLinearized()) {
5016 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5017 } else {
5018 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHggRatio());
5019 }
5020}
5021
5022mummHWW::mummHWW(const StandardModel& SM_i, const double sqrt_s_i)
5023: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5024{
5025 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5026 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5027}
5028
5030{
5031 if ((this->getModel()).isModelLinearized()) {
5032 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5033 } else {
5034 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHWWRatio());
5035 }
5036}
5037
5038mummHtautau::mummHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5039: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5040{
5041 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5042 throw std::runtime_error("mummHtautau called with a class whose parent is not NPbase");
5043}
5044
5046{
5047 if ((this->getModel()).isModelLinearized()) {
5048 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5049 } else {
5051 }
5052}
5053
5054mummHZZ::mummHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5055: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5056{
5057 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5058 throw std::runtime_error("mummHZZ called with a class whose parent is not NPbase");
5059}
5060
5062{
5063 if ((this->getModel()).isModelLinearized()) {
5064 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5065 } else {
5066 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZZRatio());
5067 }
5068}
5069
5070mummHZga::mummHZga(const StandardModel& SM_i, const double sqrt_s_i)
5071: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5072{
5073 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5074 throw std::runtime_error("mummHZga called with a class whose parent is not NPbase");
5075}
5076
5078{
5079 if ((this->getModel()).isModelLinearized()) {
5080 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5081 } else {
5082 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZgaRatio());
5083 }
5084}
5085
5086mummHgaga::mummHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5087: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5088{
5089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5090 throw std::runtime_error("mummHgaga called with a class whose parent is not NPbase");
5091}
5092
5094{
5095 if ((this->getModel()).isModelLinearized()) {
5096 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5097 } else {
5098 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHgagaRatio());
5099 }
5100}
5101
5102mummHmumu::mummHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5103: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5104{
5105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5106 throw std::runtime_error("mummHmumu called with a class whose parent is not NPbase");
5107}
5108
5110{
5111 if ((this->getModel()).isModelLinearized()) {
5112 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5113 } else {
5114 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHmumuRatio());
5115 }
5116}
5117
5118
5119
5120mummZHbb::mummZHbb(const StandardModel& SM_i, const double sqrt_s_i)
5121: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5122{
5123 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5124 throw std::runtime_error("mummZHbb called with a class whose parent is not NPbase");
5125}
5126
5128{
5129 if ((this->getModel()).isModelLinearized()) {
5130 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5131 } else {
5132 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHbbRatio());
5133 }
5134}
5135
5136mummZHcc::mummZHcc(const StandardModel& SM_i, const double sqrt_s_i)
5137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5138{
5139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5140 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5141}
5142
5144{
5145 if ((this->getModel()).isModelLinearized()) {
5146 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5147 } else {
5148 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHccRatio());
5149 }
5150}
5151
5152mummZHgg::mummZHgg(const StandardModel& SM_i, const double sqrt_s_i)
5153: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5154{
5155 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5156 throw std::runtime_error("mummZHgg called with a class whose parent is not NPbase");
5157}
5158
5160{
5161 if ((this->getModel()).isModelLinearized()) {
5162 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5163 } else {
5164 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHggRatio());
5165 }
5166}
5167
5168mummZHWW::mummZHWW(const StandardModel& SM_i, const double sqrt_s_i)
5169: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5170{
5171 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5172 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5173}
5174
5176{
5177 if ((this->getModel()).isModelLinearized()) {
5178 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5179 } else {
5180 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHWWRatio());
5181 }
5182}
5183
5184mummZHtautau::mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5185: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5186{
5187 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5188 throw std::runtime_error("mummZHtautau called with a class whose parent is not NPbase");
5189}
5190
5192{
5193 if ((this->getModel()).isModelLinearized()) {
5194 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5195 } else {
5197 }
5198}
5199
5200mummZHZZ::mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5201: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5202{
5203 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5204 throw std::runtime_error("mummZHZZ called with a class whose parent is not NPbase");
5205}
5206
5208{
5209 if ((this->getModel()).isModelLinearized()) {
5210 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5211 } else {
5212 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZZRatio());
5213 }
5214}
5215
5216mummZHZga::mummZHZga(const StandardModel& SM_i, const double sqrt_s_i)
5217: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5218{
5219 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5220 throw std::runtime_error("mummZHZga called with a class whose parent is not NPbase");
5221}
5222
5224{
5225 if ((this->getModel()).isModelLinearized()) {
5226 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5227 } else {
5228 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZgaRatio());
5229 }
5230}
5231
5232mummZHgaga::mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5233: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5234{
5235 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5236 throw std::runtime_error("mummZHgaga called with a class whose parent is not NPbase");
5237}
5238
5240{
5241 if ((this->getModel()).isModelLinearized()) {
5242 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5243 } else {
5244 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHgagaRatio());
5245 }
5246}
5247
5248mummZHmumu::mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5249: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5250{
5251 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5252 throw std::runtime_error("mummZHmumu called with a class whose parent is not NPbase");
5253}
5254
5256{
5257 if ((this->getModel()).isModelLinearized()) {
5258 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5259 } else {
5260 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHmumuRatio());
5261 }
5262}
5263
5264
5265
5266mummHvvbb::mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
5267: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5268{
5269 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5270 throw std::runtime_error("mummHvvbb called with a class whose parent is not NPbase");
5271}
5272
5274{
5275 if ((this->getModel()).isModelLinearized()) {
5276 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5277 } else {
5278 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHbbRatio());
5279 }
5280}
5281
5282mummHvvcc::mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
5283: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5284{
5285 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5286 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5287}
5288
5290{
5291 if ((this->getModel()).isModelLinearized()) {
5292 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5293 } else {
5294 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHccRatio());
5295 }
5296}
5297
5298mummHvvgg::mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
5299: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5300{
5301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5302 throw std::runtime_error("mummHvvgg called with a class whose parent is not NPbase");
5303}
5304
5306{
5307 if ((this->getModel()).isModelLinearized()) {
5308 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5309 } else {
5310 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHggRatio());
5311 }
5312}
5313
5314mummHvvWW::mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
5315: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5316{
5317 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5318 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5319}
5320
5322{
5323 if ((this->getModel()).isModelLinearized()) {
5324 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5325 } else {
5326 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHWWRatio());
5327 }
5328}
5329
5330mummHvvtautau::mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
5331: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5332{
5333 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5334 throw std::runtime_error("mummHvvtautau called with a class whose parent is not NPbase");
5335}
5336
5338{
5339 if ((this->getModel()).isModelLinearized()) {
5340 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5341 } else {
5343 }
5344}
5345
5346mummHvvZZ::mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
5347: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5348{
5349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5350 throw std::runtime_error("mummHvvZZ called with a class whose parent is not NPbase");
5351}
5352
5354{
5355 if ((this->getModel()).isModelLinearized()) {
5356 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5357 } else {
5358 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZZRatio());
5359 }
5360}
5361
5362mummHvvZga::mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
5363: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5364{
5365 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5366 throw std::runtime_error("mummHvvZga called with a class whose parent is not NPbase");
5367}
5368
5370{
5371 if ((this->getModel()).isModelLinearized()) {
5372 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5373 } else {
5374 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
5375 }
5376}
5377
5378mummHvvgaga::mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
5379: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5380{
5381 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5382 throw std::runtime_error("mummHvvgaga called with a class whose parent is not NPbase");
5383}
5384
5386{
5387 if ((this->getModel()).isModelLinearized()) {
5388 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5389 } else {
5391 }
5392}
5393
5394mummHvvmumu::mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
5395: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5396{
5397 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5398 throw std::runtime_error("mummHvvmumu called with a class whose parent is not NPbase");
5399}
5400
5402{
5403 if ((this->getModel()).isModelLinearized()) {
5404 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5405 } else {
5407 }
5408}
5409
5410
5411
5412mummHmmbb::mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i)
5413: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5414{
5415 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5416 throw std::runtime_error("mummHmmbb called with a class whose parent is not NPbase");
5417}
5418
5420{
5421 if ((this->getModel()).isModelLinearized()) {
5422 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5423 } else {
5424 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHbbRatio());
5425 }
5426}
5427
5428mummHmmcc::mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i)
5429: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5430{
5431 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5432 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5433}
5434
5436{
5437 if ((this->getModel()).isModelLinearized()) {
5438 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5439 } else {
5440 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHccRatio());
5441 }
5442}
5443
5444mummHmmgg::mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i)
5445: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5446{
5447 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5448 throw std::runtime_error("mummHmmgg called with a class whose parent is not NPbase");
5449}
5450
5452{
5453 if ((this->getModel()).isModelLinearized()) {
5454 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5455 } else {
5456 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHggRatio());
5457 }
5458}
5459
5460mummHmmWW::mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i)
5461: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5462{
5463 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5464 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5465}
5466
5468{
5469 if ((this->getModel()).isModelLinearized()) {
5470 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5471 } else {
5472 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHWWRatio());
5473 }
5474}
5475
5476mummHmmtautau::mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i)
5477: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5478{
5479 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5480 throw std::runtime_error("mummHmmtautau called with a class whose parent is not NPbase");
5481}
5482
5484{
5485 if ((this->getModel()).isModelLinearized()) {
5486 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5487 } else {
5489 }
5490}
5491
5492mummHmmZZ::mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i)
5493: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5494{
5495 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5496 throw std::runtime_error("mummHmmZZ called with a class whose parent is not NPbase");
5497}
5498
5500{
5501 if ((this->getModel()).isModelLinearized()) {
5502 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5503 } else {
5504 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZZRatio());
5505 }
5506}
5507
5508mummHmmZga::mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i)
5509: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5510{
5511 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5512 throw std::runtime_error("mummHmmZga called with a class whose parent is not NPbase");
5513}
5514
5516{
5517 if ((this->getModel()).isModelLinearized()) {
5518 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5519 } else {
5520 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZgaRatio());
5521 }
5522}
5523
5524mummHmmgaga::mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i)
5525: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5526{
5527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5528 throw std::runtime_error("mummHmmgaga called with a class whose parent is not NPbase");
5529}
5530
5532{
5533 if ((this->getModel()).isModelLinearized()) {
5534 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5535 } else {
5537 }
5538}
5539
5540mummHmmmumu::mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i)
5541: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5542{
5543 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5544 throw std::runtime_error("mummHmmmumu called with a class whose parent is not NPbase");
5545}
5546
5548{
5549 if ((this->getModel()).isModelLinearized()) {
5550 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5551 } else {
5553 }
5554}
5555
5556
5557mummttHbb::mummttHbb(const StandardModel& SM_i, const double sqrt_s_i)
5558: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5559{
5560 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5561 throw std::runtime_error("mummttHbb called with a class whose parent is not NPbase");
5562}
5563
5565{
5566 if ((this->getModel()).isModelLinearized()) {
5567 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5568 } else {
5569 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHbbRatio());
5570 }
5571}
5572
5573mummttHcc::mummttHcc(const StandardModel& SM_i, const double sqrt_s_i)
5574: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5575{
5576 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5577 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5578}
5579
5581{
5582 if ((this->getModel()).isModelLinearized()) {
5583 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5584 } else {
5585 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHccRatio());
5586 }
5587}
5588
5589mummttHgg::mummttHgg(const StandardModel& SM_i, const double sqrt_s_i)
5590: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5591{
5592 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5593 throw std::runtime_error("mummttHgg called with a class whose parent is not NPbase");
5594}
5595
5597{
5598 if ((this->getModel()).isModelLinearized()) {
5599 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5600 } else {
5601 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHggRatio());
5602 }
5603}
5604
5605mummttHWW::mummttHWW(const StandardModel& SM_i, const double sqrt_s_i)
5606: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5607{
5608 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5609 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5610}
5611
5613{
5614 if ((this->getModel()).isModelLinearized()) {
5615 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5616 } else {
5617 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHWWRatio());
5618 }
5619}
5620
5621mummttHtautau::mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5622: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5623{
5624 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5625 throw std::runtime_error("mummttHtautau called with a class whose parent is not NPbase");
5626}
5627
5629{
5630 if ((this->getModel()).isModelLinearized()) {
5631 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5632 } else {
5634 }
5635}
5636
5637mummttHZZ::mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5638: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5639{
5640 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5641 throw std::runtime_error("mummttHZZ called with a class whose parent is not NPbase");
5642}
5643
5645{
5646 if ((this->getModel()).isModelLinearized()) {
5647 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5648 } else {
5649 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZZRatio());
5650 }
5651}
5652
5653mummttHZga::mummttHZga(const StandardModel& SM_i, const double sqrt_s_i)
5654: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5655{
5656 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5657 throw std::runtime_error("mummttHZga called with a class whose parent is not NPbase");
5658}
5659
5661{
5662 if ((this->getModel()).isModelLinearized()) {
5663 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5664 } else {
5665 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZgaRatio());
5666 }
5667}
5668
5669mummttHgaga::mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5670: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5671{
5672 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5673 throw std::runtime_error("mummttHgaga called with a class whose parent is not NPbase");
5674}
5675
5677{
5678 if ((this->getModel()).isModelLinearized()) {
5679 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5680 } else {
5682 }
5683}
5684
5685mummttHmumu::mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5686: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5687{
5688 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5689 throw std::runtime_error("mummttHmumu called with a class whose parent is not NPbase");
5690}
5691
5693{
5694 if ((this->getModel()).isModelLinearized()) {
5695 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5696 } else {
5698 }
5699}
5700
5701
5702// The same in the narrow width approximation
5703
5704mummHbbNWA::mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i)
5705: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5706{
5707 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5708 throw std::runtime_error("mummHbbNWA called with a class whose parent is not NPbase");
5709}
5710
5712{
5713 if ((this->getModel()).isModelLinearized()) {
5714 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5715 } else {
5716 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHbbRatio());
5717 }
5718}
5719
5720mummHccNWA::mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i)
5721: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5722{
5723 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5724 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5725}
5726
5728{
5729 if ((this->getModel()).isModelLinearized()) {
5730 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5731 } else {
5732 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHccRatio());
5733 }
5734}
5735
5736mummHggNWA::mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i)
5737: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5738{
5739 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5740 throw std::runtime_error("mummHggNWA called with a class whose parent is not NPbase");
5741}
5742
5744{
5745 if ((this->getModel()).isModelLinearized()) {
5746 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5747 } else {
5748 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHggRatio());
5749 }
5750}
5751
5752mummHWWNWA::mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i)
5753: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5754{
5755 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5756 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5757}
5758
5760{
5761 if ((this->getModel()).isModelLinearized()) {
5762 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5763 } else {
5764 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHWWRatio());
5765 }
5766}
5767
5768mummHtautauNWA::mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i)
5769: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5770{
5771 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5772 throw std::runtime_error("mummHtautauNWA called with a class whose parent is not NPbase");
5773}
5774
5776{
5777 if ((this->getModel()).isModelLinearized()) {
5778 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5779 } else {
5781 }
5782}
5783
5784mummHZZNWA::mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i)
5785: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5786{
5787 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5788 throw std::runtime_error("mummHZZNWA called with a class whose parent is not NPbase");
5789}
5790
5792{
5793 if ((this->getModel()).isModelLinearized()) {
5794 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5795 } else {
5796 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHZZRatio());
5797 }
5798}
5799
5800mummHZgaNWA::mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5801: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5802{
5803 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5804 throw std::runtime_error("mummHZgaNWA called with a class whose parent is not NPbase");
5805}
5806
5808{
5809 if ((this->getModel()).isModelLinearized()) {
5810 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5811 } else {
5813 }
5814}
5815
5816mummHgagaNWA::mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5817: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5818{
5819 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5820 throw std::runtime_error("mummHgagaNWA called with a class whose parent is not NPbase");
5821}
5822
5824{
5825 if ((this->getModel()).isModelLinearized()) {
5826 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5827 } else {
5829 }
5830}
5831
5832mummHmumuNWA::mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i)
5833: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5834{
5835 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5836 throw std::runtime_error("mummHmumuNWA called with a class whose parent is not NPbase");
5837}
5838
5840{
5841 if ((this->getModel()).isModelLinearized()) {
5842 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5843 } else {
5845 }
5846}
5847
5848// Full signal strengths at ep colliders
5849// -------------------------------------
5850
5851muepWBFbb::muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5852: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5853{
5854 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5855 throw std::runtime_error("muepWBFbb called with a class whose parent is not NPbase");
5856
5857}
5858
5860{
5861 if ((this->getModel()).isModelLinearized()) {
5862 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5863 } else {
5864 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHbbRatio());
5865 }
5866}
5867
5868muepWBFcc::muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5869: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5870{
5871 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5872 throw std::runtime_error("muepWBFcc called with a class whose parent is not NPbase");
5873
5874}
5875
5877{
5878 if ((this->getModel()).isModelLinearized()) {
5879 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5880 } else {
5881 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHccRatio());
5882 }
5883}
5884
5885muepWBFgg::muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5886: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5887{
5888 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5889 throw std::runtime_error("muepWBFgg called with a class whose parent is not NPbase");
5890
5891}
5892
5894{
5895 if ((this->getModel()).isModelLinearized()) {
5896 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5897 } else {
5898 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHggRatio());
5899 }
5900}
5901
5902muepWBFWW2l2v::muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5903: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5904{
5905 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5906 throw std::runtime_error("muepWBFWW2l2v called with a class whose parent is not NPbase");
5907
5908}
5909
5911{
5912 if ((this->getModel()).isModelLinearized()) {
5913 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5914 } else {
5916 }
5917}
5918
5919muepWBFZZ4l::muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5920: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5921{
5922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5923 throw std::runtime_error("muepWBFZZ4l called with a class whose parent is not NPbase");
5924
5925}
5926
5928{
5929 if ((this->getModel()).isModelLinearized()) {
5930 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5931 } else {
5932 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrH4lRatio());
5933 }
5934}
5935
5936muepWBFgaga::muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
5937: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5938{
5939 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5940 throw std::runtime_error("muepWBFgaga called with a class whose parent is not NPbase");
5941
5942}
5943
5945{
5946 if ((this->getModel()).isModelLinearized()) {
5947 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5948 } else {
5950 }
5951}
5952
5953muepWBFtautau::muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
5954: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5955{
5956 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5957 throw std::runtime_error("muepWBFtautau called with a class whose parent is not NPbase");
5958
5959}
5960
5962{
5963 if ((this->getModel()).isModelLinearized()) {
5964 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5965 } else {
5967 }
5968}
5969
5970muepZBFbb::muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5971: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5972{
5973 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5974 throw std::runtime_error("muepZBFbb called with a class whose parent is not NPbase");
5975
5976}
5977
5979{
5980 if ((this->getModel()).isModelLinearized()) {
5981 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5982 } else {
5983 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHbbRatio());
5984 }
5985}
5986
5987muepZBFcc::muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5988: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5989{
5990 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5991 throw std::runtime_error("muepZBFcc called with a class whose parent is not NPbase");
5992
5993}
5994
5996{
5997 if ((this->getModel()).isModelLinearized()) {
5998 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5999 } else {
6000 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHccRatio());
6001 }
6002}
6003
6004muepZBFgg::muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i)
6005: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6006{
6007 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6008 throw std::runtime_error("muepZBFgg called with a class whose parent is not NPbase");
6009
6010}
6011
6013{
6014 if ((this->getModel()).isModelLinearized()) {
6015 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
6016 } else {
6017 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHggRatio());
6018 }
6019}
6020
6021muepZBFWW2l2v::muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
6022: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6023{
6024 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6025 throw std::runtime_error("muepZBFWW2l2v called with a class whose parent is not NPbase");
6026
6027}
6028
6030{
6031 if ((this->getModel()).isModelLinearized()) {
6032 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
6033 } else {
6035 }
6036}
6037
6038muepZBFZZ4l::muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
6039: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6040{
6041 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6042 throw std::runtime_error("muepZBFZZ4l called with a class whose parent is not NPbase");
6043
6044}
6045
6047{
6048 if ((this->getModel()).isModelLinearized()) {
6049 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6050 } else {
6051 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrH4lRatio());
6052 }
6053}
6054
6055muepZBFgaga::muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
6056: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6057{
6058 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6059 throw std::runtime_error("muepZBFgaga called with a class whose parent is not NPbase");
6060
6061}
6062
6064{
6065 if ((this->getModel()).isModelLinearized()) {
6066 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
6067 } else {
6069 }
6070}
6071
6072muepZBFtautau::muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6073: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6074{
6075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6076 throw std::runtime_error("muepZBFtautau called with a class whose parent is not NPbase");
6077
6078}
6079
6081{
6082 if ((this->getModel()).isModelLinearized()) {
6083 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6084 } else {
6086 }
6087}
6088
6089
6090// -----------------------------------------------------------------------------
6091// STXS bins
6092// -----------------------------------------------------------------------------
6093
6094// -----------------------------------------------------------------------------
6095// Stage 0
6096// -----------------------------------------------------------------------------
6097
6098STXS_0_qqH::STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i)
6099: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6100{
6101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6102 throw std::runtime_error("STXS_0_qqH called with a class whose parent is not NPbase");
6103
6104}
6105
6107{
6108 return myNPbase->STXS0_qqH(sqrt_s);
6109}
6110
6111
6112// -----------------------------------------------------------------------------
6113// Stage 1
6114// -----------------------------------------------------------------------------
6115
6117: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6118{
6119 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6120 throw std::runtime_error("STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6121
6122}
6123
6125{
6126 if ((this->getModel()).isModelLinearized()) {
6127 return ((myNPbase->STXS_ggH_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6128 } else {
6130 }
6131}
6132
6133
6135: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6136{
6137 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6138 throw std::runtime_error("STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6139
6140}
6141
6143{
6144 if ((this->getModel()).isModelLinearized()) {
6145 return ((myNPbase->STXS_ggH_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6146 } else {
6148 }
6149}
6150
6151
6152STXSggH0j4l::STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i)
6153: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6154{
6155 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6156 throw std::runtime_error("STXSggH0j4l called with a class whose parent is not NPbase");
6157
6158}
6159
6161{
6162 if ((this->getModel()).isModelLinearized()) {
6163 return ((myNPbase->STXS_ggH0j(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6164 } else {
6166 }
6167}
6168
6170: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6171{
6172 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6173 throw std::runtime_error("STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6174
6175}
6176
6178{
6179 if ((this->getModel()).isModelLinearized()) {
6180 return ((myNPbase->STXS_ggH1j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6181 } else {
6183 }
6184}
6185
6187: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6188{
6189 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6190 throw std::runtime_error("STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6191
6192}
6193
6195{
6196 if ((this->getModel()).isModelLinearized()) {
6197 return ((myNPbase->STXS_ggH1j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6198 } else {
6200 }
6201}
6202
6204: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6205{
6206 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6207 throw std::runtime_error("STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6208
6209}
6210
6212{
6213 if ((this->getModel()).isModelLinearized()) {
6214 return ((myNPbase->STXS_ggH1j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6215 } else {
6217 }
6218}
6219
6221: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6222{
6223 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6224 throw std::runtime_error("STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6225
6226}
6227
6229{
6230 if ((this->getModel()).isModelLinearized()) {
6231 return ((myNPbase->STXS_ggH1j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6232 } else {
6234 }
6235}
6236
6238: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6239{
6240 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6241 throw std::runtime_error("STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6242
6243}
6244
6246{
6247 if ((this->getModel()).isModelLinearized()) {
6248 return ((myNPbase->STXS_ggH2j_pTH_0_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6249 } else {
6251 }
6252}
6253
6254
6256: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6257{
6258 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6259 throw std::runtime_error("STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6260
6261}
6262
6264{
6265 if ((this->getModel()).isModelLinearized()) {
6266 return ((myNPbase->STXS_ggH2j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6267 } else {
6269 }
6270}
6271
6272
6274: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6275{
6276 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6277 throw std::runtime_error("STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6278
6279}
6280
6282{
6283 if ((this->getModel()).isModelLinearized()) {
6284 return ((myNPbase->STXS_ggH2j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6285 } else {
6287 }
6288}
6289
6290
6292: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6293{
6294 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6295 throw std::runtime_error("STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6296
6297}
6298
6300{
6301 if ((this->getModel()).isModelLinearized()) {
6302 return ((myNPbase->STXS_ggH2j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6303 } else {
6305 }
6306}
6307
6308
6310: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6311{
6312 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6313 throw std::runtime_error("STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6314
6315}
6316
6318{
6319 if ((this->getModel()).isModelLinearized()) {
6320 return ((myNPbase->STXS_ggH2j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6321 } else {
6323 }
6324}
6325
6326
6328: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6329{
6330 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6331 throw std::runtime_error("STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6332
6333}
6334
6336{
6337 if ((this->getModel()).isModelLinearized()) {
6338 return ((myNPbase->STXS_qqHqq_VBFtopo_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6339 } else {
6341 }
6342}
6343
6344
6346: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6347{
6348 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6349 throw std::runtime_error("STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6350
6351}
6352
6354{
6355 if ((this->getModel()).isModelLinearized()) {
6356 return ((myNPbase->STXS_qqHqq_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6357 } else {
6359 }
6360}
6361
6362
6363
6365: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6366{
6367 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6368 throw std::runtime_error("STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6369
6370}
6371
6373{
6374 if ((this->getModel()).isModelLinearized()) {
6375 return ((myNPbase->STXS_qqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6376 } else {
6378 }
6379}
6380
6381
6382
6384: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6385{
6386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6387 throw std::runtime_error("STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6388
6389}
6390
6392{
6393 if ((this->getModel()).isModelLinearized()) {
6394 return ((myNPbase->STXS_qqHqq_nonVHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6395 } else {
6397 }
6398}
6399
6400
6401
6403: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6404{
6405 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6406 throw std::runtime_error("STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6407
6408}
6409
6411{
6412 if ((this->getModel()).isModelLinearized()) {
6413 return ((myNPbase->STXS_qqHqq_VHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6414 } else {
6416 }
6417}
6418
6419
6420STXSqqHqq_Rest_4l::STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i)
6421: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6422{
6423 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6424 throw std::runtime_error("STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6425
6426}
6427
6429{
6430 if ((this->getModel()).isModelLinearized()) {
6431 return ((myNPbase->STXS_qqHqq_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6432 } else {
6434 }
6435}
6436
6437
6439: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6440{
6441 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6442 throw std::runtime_error("STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6443
6444}
6445
6447{
6448 if ((this->getModel()).isModelLinearized()) {
6449 return ((myNPbase->STXS_qqHqq_pTj_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6450 } else {
6452 }
6453}
6454
6456: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6457{
6458 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6459 throw std::runtime_error("STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6460
6461}
6462
6464{
6465 if ((this->getModel()).isModelLinearized()) {
6466 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6467 } else {
6469 }
6470}
6471
6472
6474: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6475{
6476 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6477 throw std::runtime_error("STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6478
6479}
6480
6482{
6483 if ((this->getModel()).isModelLinearized()) {
6484 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6485 } else {
6487 }
6488}
6489
6490
6491
6493: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6494{
6495 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6496 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6497
6498}
6499
6501{
6502 if ((this->getModel()).isModelLinearized()) {
6504 } else {
6506 }
6507}
6508
6509
6510
6512: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6513{
6514 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6515 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6516
6517}
6518
6520{
6521 if ((this->getModel()).isModelLinearized()) {
6523 } else {
6525 }
6526}
6527
6528
6530: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6531{
6532 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6533 throw std::runtime_error("STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6534
6535}
6536
6538{
6539 if ((this->getModel()).isModelLinearized()) {
6540 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6541 } else {
6543 }
6544}
6545
6547: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6548{
6549 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6550 throw std::runtime_error("STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6551
6552}
6553
6555{
6556 if ((this->getModel()).isModelLinearized()) {
6557 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6558 } else {
6560 }
6561}
6562
6564: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6565{
6566 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6567 throw std::runtime_error("STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6568
6569}
6570
6572{
6573 if ((this->getModel()).isModelLinearized()) {
6574 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6575 } else {
6577 }
6578}
6579
6580
6582: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6583{
6584 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6585 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6586
6587}
6588
6590{
6591 if ((this->getModel()).isModelLinearized()) {
6593 } else {
6595 }
6596}
6597
6598
6600: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6601{
6602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6603 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6604
6605}
6606
6608{
6609 if ((this->getModel()).isModelLinearized()) {
6611 } else {
6613 }
6614}
6615
6616
6618: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6619{
6620 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6621 throw std::runtime_error("STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6622
6623}
6624
6626{
6627 if ((this->getModel()).isModelLinearized()) {
6628 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6629 } else {
6631 }
6632}
6633
6634STXSttHtH4l::STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i)
6635: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6636{
6637 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6638 throw std::runtime_error("STXSttHtH4l called with a class whose parent is not NPbase");
6639
6640}
6641
6643{
6644 if ((this->getModel()).isModelLinearized()) {
6645 return ((myNPbase->STXS_ttHtH(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6646 } else {
6648 }
6649}
6650
6651
6653: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6654{
6655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6656 throw std::runtime_error("STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6657
6658}
6659
6661{
6662 if ((this->getModel()).isModelLinearized()) {
6663 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6664 } else {
6666 }
6667}
6668
6669
6671: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6672{
6673 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6674 throw std::runtime_error("STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6675
6676}
6677
6679{
6680 if ((this->getModel()).isModelLinearized()) {
6681 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6682 } else {
6684 }
6685}
6686
6687
6688
6690: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6691{
6692 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6693 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6694
6695}
6696
6698{
6699 if ((this->getModel()).isModelLinearized()) {
6701 } else {
6703 }
6704}
6705
6706
6707
6709: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6710{
6711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6712 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6713
6714}
6715
6717{
6718 if ((this->getModel()).isModelLinearized()) {
6720 } else {
6722 }
6723}
6724
6725
6727: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6728{
6729 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6730 throw std::runtime_error("STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6731
6732}
6733
6735{
6736 if ((this->getModel()).isModelLinearized()) {
6737 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6738 } else {
6740 }
6741}
6742
6744: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6745{
6746 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6747 throw std::runtime_error("STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6748
6749}
6750
6752{
6753 if ((this->getModel()).isModelLinearized()) {
6754 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6755 } else {
6757 }
6758}
6759
6761: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6762{
6763 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6764 throw std::runtime_error("STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6765
6766}
6767
6769{
6770 if ((this->getModel()).isModelLinearized()) {
6771 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6772 } else {
6774 }
6775}
6776
6777
6779: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6780{
6781 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6782 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6783
6784}
6785
6787{
6788 if ((this->getModel()).isModelLinearized()) {
6790 } else {
6792 }
6793}
6794
6795
6797: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6798{
6799 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6800 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6801
6802}
6803
6805{
6806 if ((this->getModel()).isModelLinearized()) {
6808 } else {
6810 }
6811}
6812
6813
6815: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6816{
6817 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6818 throw std::runtime_error("STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6819
6820}
6821
6823{
6824 if ((this->getModel()).isModelLinearized()) {
6825 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6826 } else {
6828 }
6829}
6830
6831
6833: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6834{
6835 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6836 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6837
6838}
6839
6841{
6842 if ((this->getModel()).isModelLinearized()) {
6844 } else {
6846 }
6847}
6848
6849
6851: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6852{
6853 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6854 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6855
6856}
6857
6859{
6860 if ((this->getModel()).isModelLinearized()) {
6861 return ((myNPbase->STXS_WHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6862 } else {
6864 }
6865}
6866
6867
6869: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6870{
6871 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6872 throw std::runtime_error("STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6873
6874}
6875
6877{
6878 if ((this->getModel()).isModelLinearized()) {
6879 return ((myNPbase->STXS_WHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6880 } else {
6882 }
6883}
6884
6885
6887: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6888{
6889 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6890 throw std::runtime_error("STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6891
6892}
6893
6895{
6896 if ((this->getModel()).isModelLinearized()) {
6897 return ((myNPbase->STXS_WHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6898 } else {
6900 }
6901}
6902
6903
6905: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6906{
6907 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6908 throw std::runtime_error("STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6909
6910}
6911
6913{
6914 if ((this->getModel()).isModelLinearized()) {
6915 return ((myNPbase->STXS_WHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6916 } else {
6918 }
6919}
6920
6921
6923: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6924{
6925 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6926 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6927
6928}
6929
6931{
6932 if ((this->getModel()).isModelLinearized()) {
6934 } else {
6936 }
6937}
6938
6939
6941: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6942{
6943 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6944 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6945
6946}
6947
6949{
6950 if ((this->getModel()).isModelLinearized()) {
6951 return ((myNPbase->STXS_ZHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6952 } else {
6954 }
6955}
6956
6957
6959: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6960{
6961 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6962 throw std::runtime_error("STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6963
6964}
6965
6967{
6968 if ((this->getModel()).isModelLinearized()) {
6969 return ((myNPbase->STXS_ZHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6970 } else {
6972 }
6973}
6974
6975
6977: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6978{
6979 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6980 throw std::runtime_error("STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6981
6982}
6983
6985{
6986 if ((this->getModel()).isModelLinearized()) {
6987 return ((myNPbase->STXS_ZHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6988 } else {
6990 }
6991}
6992
6993
6995: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6996{
6997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6998 throw std::runtime_error("STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6999
7000}
7001
7003{
7004 if ((this->getModel()).isModelLinearized()) {
7005 return ((myNPbase->STXS_ZHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7006 } else {
7008 }
7009}
7010
7011
7012
7013// -----------------------------------------------------------------------------
7014// Stage 1.2
7015// -----------------------------------------------------------------------------
7016
7017STXS12_ggH_pTH200_300_Nj01::STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7018: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7019{
7020 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7021 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
7022
7023}
7024
7026{
7027 double BrHXXRatio = 1.0;
7028 if (fstate == 1){
7029 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7030 } else if (fstate == 2){
7031 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7032 } else if (fstate == 3){
7033 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7034 } else if (fstate == 4){
7035 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7036 } else {
7037 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
7038 }
7039
7040 if ((this->getModel()).isModelLinearized()) {
7041 return ((myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7042 } else {
7043 return (myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s))*(BrHXXRatio);
7044 }
7045}
7046
7047// -----------------------------------------------------------------------------
7048
7049STXS12_ggH_pTH300_450_Nj01::STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7050: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7051{
7052 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7053 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
7054
7055}
7056
7058{
7059 double BrHXXRatio = 1.0;
7060 if (fstate == 1){
7061 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7062 } else if (fstate == 2){
7063 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7064 } else if (fstate == 3){
7065 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7066 } else if (fstate == 4){
7067 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7068 } else {
7069 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7070 }
7071
7072 if ((this->getModel()).isModelLinearized()) {
7073 return ((myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7074 } else {
7075 return (myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s))*(BrHXXRatio);
7076 }
7077}
7078
7079// -----------------------------------------------------------------------------
7080
7081STXS12_ggH_pTH450_650_Nj01::STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7082: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7083{
7084 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7085 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7086
7087}
7088
7090{
7091 double BrHXXRatio = 1.0;
7092 if (fstate == 1){
7093 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7094 } else if (fstate == 2){
7095 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7096 } else if (fstate == 3){
7097 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7098 } else if (fstate == 4){
7099 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7100 } else {
7101 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7102 }
7103
7104 if ((this->getModel()).isModelLinearized()) {
7105 return ((myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7106 } else {
7107 return (myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s))*(BrHXXRatio);
7108 }
7109}
7110
7111// -----------------------------------------------------------------------------
7112
7113STXS12_ggH_pTH650_Inf_Nj01::STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7114: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7115{
7116 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7117 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7118
7119}
7120
7122{
7123 double BrHXXRatio = 1.0;
7124 if (fstate == 1){
7125 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7126 } else if (fstate == 2){
7127 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7128 } else if (fstate == 3){
7129 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7130 } else if (fstate == 4){
7131 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7132 } else {
7133 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7134 }
7135
7136 if ((this->getModel()).isModelLinearized()) {
7137 return ((myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7138 } else {
7139 return (myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s))*(BrHXXRatio);
7140 }
7141}
7142
7143
7144// -----------------------------------------------------------------------------
7145
7146STXS12_ggH_pTH10_Inf_Nj0::STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7147: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7148{
7149 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7150 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7151
7152}
7153
7155{
7156 //-- Production:
7157 double weight = 1.0; //If normalized to the SM
7158
7159 double muProd = myNPbase->STXS12_ggH_pTH10_Inf_Nj0(sqrt_s);
7160 double muProd1 = muProd -1.0;
7161 double muProd2 = 0.0;
7162 //-- Decay:
7163 double BrHXXRatio = 1.0;
7164 double dBrHXXRatio1 = 0.0;
7165 double dBrHXXRatio2 = 0.0;
7166
7167 if (fstate == 1){
7168 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7169 dBrHXXRatio1 = BrHXXRatio - 1.0;
7170 dBrHXXRatio2 = 0.0;
7171 } else if (fstate == 2){
7172 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7173 dBrHXXRatio1 = BrHXXRatio - 1.0;
7174 dBrHXXRatio2 = 0.0;
7175 } else if (fstate == 3){
7176 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7177 dBrHXXRatio1 = BrHXXRatio - 1.0;
7178 dBrHXXRatio2 = 0.0;
7179 } else if (fstate == 4){
7180 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7181 dBrHXXRatio1 = BrHXXRatio - 1.0;
7182 dBrHXXRatio2 = 0.0;
7183 } else {
7184 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7185 }
7186
7187 //-- Production x Decay:
7188 if ((this->getModel()).isModelLinearized()){
7189 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7190 } else if((this->getModel()).isModelNPquadratic()){
7191 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7192 } else {
7193 return weight*(muProd)*(BrHXXRatio);
7194 }
7195}
7196
7197
7198
7199
7200
7201// -----------------------------------------------------------------------------
7202
7203//VM:STXS2024;
7204STXS12_ggH_pTH0_10_Nj0::STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7205: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7206{
7207 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7208 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7209
7210}
7211
7213{
7214 //-- Production:
7215 double weight = 1.0; //If normalized to the SM
7216 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7217 double muProd = myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s);
7218 double muProd1 = muProd -1.0;
7219 double muProd2 = 0.0;
7220
7221 //-- Decay:
7222 double BrHXXRatio = 1.0;
7223 double dBrHXXRatio1 = 0.0;
7224 double dBrHXXRatio2 = 0.0;
7225 if (fstate==0){
7226 // Use for Cross-section [pb] with no Higgs-boson decay
7227 weight = (6.6369); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7228 } else if (fstate == 1){
7229 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7230 dBrHXXRatio1 = BrHXXRatio - 1.0;
7231 dBrHXXRatio2 = 0.0;
7232 } else if (fstate == 2){
7233 BrHXXRatio = (myNPbase->BrHgagaRatio());
7234 dBrHXXRatio1 = BrHXXRatio - 1.0;
7235 dBrHXXRatio2 = 0.0;
7236 } else if (fstate == 3){
7237 BrHXXRatio = (myNPbase->BrHbbRatio());
7238 dBrHXXRatio1 = BrHXXRatio - 1.0;
7239 dBrHXXRatio2 = 0.0;
7240 } else if (fstate == 4){
7241 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7242 dBrHXXRatio1 = BrHXXRatio - 1.0;
7243 dBrHXXRatio2 = 0.0;
7244 } else if (fstate == 5){
7245 BrHXXRatio = (myNPbase->BrHtautauRatio());
7246 dBrHXXRatio1 = BrHXXRatio - 1.0;
7247 dBrHXXRatio2 = 0.0;
7248 } else if (fstate == 6){
7249 BrHXXRatio = (myNPbase->BrHWWRatio());
7250 dBrHXXRatio1 = BrHXXRatio - 1.0;
7251 dBrHXXRatio2 = 0.0;
7252 } else if (fstate == 7){
7253 BrHXXRatio = (myNPbase->BrHZZRatio());
7254 dBrHXXRatio1 = BrHXXRatio - 1.0;
7255 dBrHXXRatio2 = 0.0;
7256 } else {
7257 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7258 }
7259
7260 //-- Production x Decay:
7261 if ((this->getModel()).isModelLinearized()){
7262 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7263 } else if((this->getModel()).isModelNPquadratic()){
7264 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7265 } else {
7266 return weight*(muProd)*(BrHXXRatio);
7267 }
7268
7269}
7270
7271
7272
7273// -----------------------------------------------------------------------------
7274
7275//VM:STXS2024;
7276STXS12_ggH_pTH10_200_Nj0::STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7277: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7278{
7279 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7280 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7281
7282}
7283
7285{
7286 //-- Production:
7287 double weight = 1.0; //If normalized to the SM
7288 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7289 double muProd = myNPbase->STXS12_ggH_pTH10_200_Nj0(sqrt_s);
7290 double muProd1 = muProd -1.0;
7291 double muProd2 = 0.0;
7292
7293 //-- Decay:
7294 double BrHXXRatio = 1.0;
7295 double dBrHXXRatio1 = 0.0;
7296 double dBrHXXRatio2 = 0.0;
7297 if (fstate==0){
7298 // Use for Cross-section [pb] with no Higgs-boson decay
7299 weight = (20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7300 } else if (fstate == 1){
7301 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7302 dBrHXXRatio1 = BrHXXRatio - 1.0;
7303 dBrHXXRatio2 = 0.0;
7304 } else if (fstate == 2){
7305 BrHXXRatio = (myNPbase->BrHgagaRatio());
7306 dBrHXXRatio1 = BrHXXRatio - 1.0;
7307 dBrHXXRatio2 = 0.0;
7308 } else if (fstate == 3){
7309 BrHXXRatio = (myNPbase->BrHbbRatio());
7310 dBrHXXRatio1 = BrHXXRatio - 1.0;
7311 dBrHXXRatio2 = 0.0;
7312 } else if (fstate == 4){
7313 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7314 dBrHXXRatio1 = BrHXXRatio - 1.0;
7315 dBrHXXRatio2 = 0.0;
7316 } else if (fstate == 5){
7317 BrHXXRatio = (myNPbase->BrHtautauRatio());
7318 dBrHXXRatio1 = BrHXXRatio - 1.0;
7319 dBrHXXRatio2 = 0.0;
7320 } else if (fstate == 6){
7321 BrHXXRatio = (myNPbase->BrHWWRatio());
7322 dBrHXXRatio1 = BrHXXRatio - 1.0;
7323 dBrHXXRatio2 = 0.0;
7324 } else if (fstate == 7){
7325 BrHXXRatio = (myNPbase->BrHZZRatio());
7326 dBrHXXRatio1 = BrHXXRatio - 1.0;
7327 dBrHXXRatio2 = 0.0;
7328 } else {
7329 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7330 }
7331
7332 //-- Production x Decay:
7333 if ((this->getModel()).isModelLinearized()){
7334 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7335 } else if((this->getModel()).isModelNPquadratic()){
7336 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7337 } else {
7338 return weight*(muProd)*(BrHXXRatio);
7339 }
7340
7341}
7342
7343
7344
7345
7346// -----------------------------------------------------------------------------
7347
7348//VM:STXS2024;
7349STXS12_ggH_pTH0_200_Nj0::STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7350: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7351{
7352 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7353 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7354
7355}
7356
7358{
7359 //-- Production:
7360 double weight = 1.0; //If normalized to the SM
7361 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7362 double muProd = ( 6.6369*(myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s)) +
7364 /(6.6369 + 20.642);
7365 double muProd1 = muProd -1.0;
7366 double muProd2 = 0.0;
7367
7368 //-- Decay:
7369 double BrHXXRatio = 1.0;
7370 double dBrHXXRatio1 = 0.0;
7371 double dBrHXXRatio2 = 0.0;
7372 if (fstate==0){
7373 // Use for Cross-section [pb] with no Higgs-boson decay
7374 weight = (6.6369 + 20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7375 } else if (fstate == 1){
7376 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7377 dBrHXXRatio1 = BrHXXRatio - 1.0;
7378 dBrHXXRatio2 = 0.0;
7379 } else if (fstate == 2){
7380 BrHXXRatio = (myNPbase->BrHgagaRatio());
7381 dBrHXXRatio1 = BrHXXRatio - 1.0;
7382 dBrHXXRatio2 = 0.0;
7383 } else if (fstate == 3){
7384 BrHXXRatio = (myNPbase->BrHbbRatio());
7385 dBrHXXRatio1 = BrHXXRatio - 1.0;
7386 dBrHXXRatio2 = 0.0;
7387 } else if (fstate == 4){
7388 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7389 dBrHXXRatio1 = BrHXXRatio - 1.0;
7390 dBrHXXRatio2 = 0.0;
7391 } else if (fstate == 5){
7392 BrHXXRatio = (myNPbase->BrHtautauRatio());
7393 dBrHXXRatio1 = BrHXXRatio - 1.0;
7394 dBrHXXRatio2 = 0.0;
7395 } else if (fstate == 6){
7396 BrHXXRatio = (myNPbase->BrHWWRatio());
7397 dBrHXXRatio1 = BrHXXRatio - 1.0;
7398 dBrHXXRatio2 = 0.0;
7399 } else if (fstate == 7){
7400 BrHXXRatio = (myNPbase->BrHZZRatio());
7401 dBrHXXRatio1 = BrHXXRatio - 1.0;
7402 dBrHXXRatio2 = 0.0;
7403 } else {
7404 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7405 }
7406
7407 //-- Production x Decay:
7408 if ((this->getModel()).isModelLinearized()){
7409 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7410 } else if((this->getModel()).isModelNPquadratic()){
7411 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7412 } else {
7413 return weight*(muProd)*(BrHXXRatio);
7414 }
7415
7416}
7417
7418
7419
7420
7421// -----------------------------------------------------------------------------
7422
7423//VM:STXS2024;
7424STXS12_ggH_mjj0_350_pTH0_60_Nj1::STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7425: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7426{
7427 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7428 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7429
7430}
7431
7433{
7434 //-- Production:
7435 double weight = 1.0; //If normalized to the SM
7436 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7437
7438 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj1(sqrt_s)) );
7439 double muProd1 = muProd -1.0;
7440 double muProd2 = 0.0;
7441
7442 //-- Decay:
7443 double BrHXXRatio = 1.0;
7444 double dBrHXXRatio1 = 0.0;
7445 double dBrHXXRatio2 = 0.0;
7446 if (fstate==0){
7447 // Use for Cross-section [pb] with no Higgs-boson decay
7448 weight = (1.); //NOT in Ref: https://www.hepdata.net/record/ins2104706 Figure7. Missing SM prediction!!!
7449 } else if (fstate == 1){
7450 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7451 dBrHXXRatio1 = BrHXXRatio - 1.0;
7452 dBrHXXRatio2 = 0.0;
7453 } else if (fstate == 2){
7454 BrHXXRatio = (myNPbase->BrHgagaRatio());
7455 dBrHXXRatio1 = BrHXXRatio - 1.0;
7456 dBrHXXRatio2 = 0.0;
7457 } else if (fstate == 3){
7458 BrHXXRatio = (myNPbase->BrHbbRatio());
7459 dBrHXXRatio1 = BrHXXRatio - 1.0;
7460 dBrHXXRatio2 = 0.0;
7461 } else if (fstate == 4){
7462 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7463 dBrHXXRatio1 = BrHXXRatio - 1.0;
7464 dBrHXXRatio2 = 0.0;
7465 } else if (fstate == 5){
7466 BrHXXRatio = (myNPbase->BrHtautauRatio());
7467 dBrHXXRatio1 = BrHXXRatio - 1.0;
7468 dBrHXXRatio2 = 0.0;
7469 } else if (fstate == 6){
7470 BrHXXRatio = (myNPbase->BrHWWRatio());
7471 dBrHXXRatio1 = BrHXXRatio - 1.0;
7472 dBrHXXRatio2 = 0.0;
7473 } else if (fstate == 7){
7474 BrHXXRatio = (myNPbase->BrHZZRatio());
7475 dBrHXXRatio1 = BrHXXRatio - 1.0;
7476 dBrHXXRatio2 = 0.0;
7477 } else {
7478 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7479 }
7480
7481 //-- Production x Decay:
7482 if ((this->getModel()).isModelLinearized()){
7483 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7484 } else if((this->getModel()).isModelNPquadratic()){
7485 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7486 } else {
7487 return weight*(muProd)*(BrHXXRatio);
7488 }
7489
7490}
7491
7492
7493
7494
7495
7496
7497
7498// -----------------------------------------------------------------------------
7499
7500//AG:STXS2024
7501STXS12_ggH_pTH0_60_Nj1::STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7502: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7503{
7504 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7505 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7506
7507}
7508
7510{
7511 //-- Production:
7512 double weight = 1.0; //If normalized to the SM
7513 double muProd = myNPbase->STXS12_ggH_pTH0_60_Nj1(sqrt_s);
7514 double muProd1 = muProd -1.0;
7515 double muProd2 = 0.0;
7516
7517 //-- Decay:
7518 double BrHXXRatio = 1.0;
7519 double dBrHXXRatio1 = 0.0;
7520 double dBrHXXRatio2 = 0.0;
7521 if (fstate==0){
7522 // Use for Cross-section [pb] with no Higgs-boson decay
7523 weight = 6.50045; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7524 } else if (fstate == 1){
7525 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7526 dBrHXXRatio1 = BrHXXRatio - 1.0;
7527 dBrHXXRatio2 = 0.0;
7528 } else if (fstate == 2){
7529 BrHXXRatio = (myNPbase->BrHgagaRatio());
7530 dBrHXXRatio1 = BrHXXRatio - 1.0;
7531 dBrHXXRatio2 = 0.0;
7532 } else if (fstate == 3){
7533 BrHXXRatio = (myNPbase->BrHbbRatio());
7534 dBrHXXRatio1 = BrHXXRatio - 1.0;
7535 dBrHXXRatio2 = 0.0;
7536 } else if (fstate == 4){
7537 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7538 dBrHXXRatio1 = BrHXXRatio - 1.0;
7539 dBrHXXRatio2 = 0.0;
7540 } else if (fstate == 5){
7541 BrHXXRatio = (myNPbase->BrHtautauRatio());
7542 dBrHXXRatio1 = BrHXXRatio - 1.0;
7543 dBrHXXRatio2 = 0.0;
7544 } else if (fstate == 6){
7545 BrHXXRatio = (myNPbase->BrHWWRatio());
7546 dBrHXXRatio1 = BrHXXRatio - 1.0;
7547 dBrHXXRatio2 = 0.0;
7548 } else if (fstate == 7){
7549 BrHXXRatio = (myNPbase->BrHZZRatio());
7550 dBrHXXRatio1 = BrHXXRatio - 1.0;
7551 dBrHXXRatio2 = 0.0;
7552 } else {
7553 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7554 }
7555
7556 //-- Production x Decay:
7557 if ((this->getModel()).isModelLinearized()){
7558 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7559 } else if((this->getModel()).isModelNPquadratic()){
7560 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7561 } else {
7562 return weight*(muProd)*(BrHXXRatio);
7563 }
7564
7565}
7566
7567// -----------------------------------------------------------------------------
7568
7569//AG:STXS2024
7570STXS12_ggH_pTH60_120_Nj1::STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7571: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7572{
7573 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7574 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7575
7576}
7577
7579{
7580 //-- Production:
7581 double weight = 1.0; //If normalized to the SM
7582 double muProd = myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s);
7583 double muProd1 = muProd -1.0;
7584 double muProd2 = 0.0;
7585
7586 //-- Decay:
7587 double BrHXXRatio = 1.0;
7588 double dBrHXXRatio1 = 0.0;
7589 double dBrHXXRatio2 = 0.0;
7590 if (fstate==0){
7591 // Use for Cross-section [pb] with no Higgs-boson decay
7592 weight = 4.50294; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7593 } else if (fstate == 1){
7594 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7595 dBrHXXRatio1 = BrHXXRatio - 1.0;
7596 dBrHXXRatio2 = 0.0;
7597 } else if (fstate == 2){
7598 BrHXXRatio = (myNPbase->BrHgagaRatio());
7599 dBrHXXRatio1 = BrHXXRatio - 1.0;
7600 dBrHXXRatio2 = 0.0;
7601 } else if (fstate == 3){
7602 BrHXXRatio = (myNPbase->BrHbbRatio());
7603 dBrHXXRatio1 = BrHXXRatio - 1.0;
7604 dBrHXXRatio2 = 0.0;
7605 } else if (fstate == 4){
7606 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7607 dBrHXXRatio1 = BrHXXRatio - 1.0;
7608 dBrHXXRatio2 = 0.0;
7609 } else if (fstate == 5){
7610 BrHXXRatio = (myNPbase->BrHtautauRatio());
7611 dBrHXXRatio1 = BrHXXRatio - 1.0;
7612 dBrHXXRatio2 = 0.0;
7613 } else if (fstate == 6){
7614 BrHXXRatio = (myNPbase->BrHWWRatio());
7615 dBrHXXRatio1 = BrHXXRatio - 1.0;
7616 dBrHXXRatio2 = 0.0;
7617 } else if (fstate == 7){
7618 BrHXXRatio = (myNPbase->BrHZZRatio());
7619 dBrHXXRatio1 = BrHXXRatio - 1.0;
7620 dBrHXXRatio2 = 0.0;
7621 } else {
7622 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7623 }
7624
7625 //-- Production x Decay:
7626 if ((this->getModel()).isModelLinearized()){
7627 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7628 } else if((this->getModel()).isModelNPquadratic()){
7629 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7630 } else {
7631 return weight*(muProd)*(BrHXXRatio);
7632 }
7633
7634}
7635
7636// -----------------------------------------------------------------------------
7637
7638//AG:STXS2024
7639STXS12_ggH_pTH120_200_Nj1::STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7640: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7641{
7642 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7643 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7644
7645}
7646
7648{
7649 //-- Production:
7650 double weight = 1.0; //If normalized to the SM
7651 double muProd = myNPbase->STXS12_ggH_pTH120_200_Nj1(sqrt_s);
7652 double muProd1 = muProd -1.0;
7653 double muProd2 = 0.0;
7654
7655 //-- Decay:
7656 double BrHXXRatio = 1.0;
7657 double dBrHXXRatio1 = 0.0;
7658 double dBrHXXRatio2 = 0.0;
7659 if (fstate==0){
7660 // Use for Cross-section [pb] with no Higgs-boson decay
7661 weight = 0.74712; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7662 } else if (fstate == 1){
7663 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7664 dBrHXXRatio1 = BrHXXRatio - 1.0;
7665 dBrHXXRatio2 = 0.0;
7666 } else if (fstate == 2){
7667 BrHXXRatio = (myNPbase->BrHgagaRatio());
7668 dBrHXXRatio1 = BrHXXRatio - 1.0;
7669 dBrHXXRatio2 = 0.0;
7670 } else if (fstate == 3){
7671 BrHXXRatio = (myNPbase->BrHbbRatio());
7672 dBrHXXRatio1 = BrHXXRatio - 1.0;
7673 dBrHXXRatio2 = 0.0;
7674 } else if (fstate == 4){
7675 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7676 dBrHXXRatio1 = BrHXXRatio - 1.0;
7677 dBrHXXRatio2 = 0.0;
7678 } else if (fstate == 5){
7679 BrHXXRatio = (myNPbase->BrHtautauRatio());
7680 dBrHXXRatio1 = BrHXXRatio - 1.0;
7681 dBrHXXRatio2 = 0.0;
7682 } else if (fstate == 6){
7683 BrHXXRatio = (myNPbase->BrHWWRatio());
7684 dBrHXXRatio1 = BrHXXRatio - 1.0;
7685 dBrHXXRatio2 = 0.0;
7686 } else if (fstate == 7){
7687 BrHXXRatio = (myNPbase->BrHZZRatio());
7688 dBrHXXRatio1 = BrHXXRatio - 1.0;
7689 dBrHXXRatio2 = 0.0;
7690 } else {
7691 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7692 }
7693
7694 //-- Production x Decay:
7695 if ((this->getModel()).isModelLinearized()){
7696 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7697 } else if((this->getModel()).isModelNPquadratic()){
7698 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7699 } else {
7700 return weight*(muProd)*(BrHXXRatio);
7701 }
7702
7703}
7704
7705// -----------------------------------------------------------------------------
7706
7707STXS12_ggH_mjj0_350_pTH0_60_Nj2::STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7708: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7709{
7710 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7711 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7712
7713}
7714
7716{
7717 double BrHXXRatio = 1.0;
7718 if (fstate == 1){
7719 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7720 } else if (fstate == 2){
7721 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7722 } else if (fstate == 3){
7723 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7724 } else if (fstate == 4){
7725 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7726 } else {
7727 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7728 }
7729
7730 if ((this->getModel()).isModelLinearized()) {
7731 return ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7732 } else {
7733 return (myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s))*(BrHXXRatio);
7734 }
7735}
7736
7737// -----------------------------------------------------------------------------
7738
7739STXS12_ggH_mjj0_350_pTH60_120_Nj2::STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7740: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7741{
7742 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7743 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
7744
7745}
7746
7748{
7749 double BrHXXRatio = 1.0;
7750 if (fstate == 1){
7751 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7752 } else if (fstate == 2){
7753 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7754 } else if (fstate == 3){
7755 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7756 } else if (fstate == 4){
7757 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7758 } else {
7759 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
7760 }
7761
7762 if ((this->getModel()).isModelLinearized()) {
7763 return ((myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7764 } else {
7765 return (myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s))*(BrHXXRatio);
7766 }
7767}
7768
7769
7770
7771
7772
7773// -----------------------------------------------------------------------------
7774
7775//VM:STXS2024;
7776STXS12_ggH_mjj0_350_pTH0_120_Nj2::STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7777: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7778{
7779 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7780 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
7781
7782}
7783
7785{
7786 //-- Production:
7787 double weight = 1.0; //If normalized to the SM
7788 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7789 //We should weight each xsection with the SM prediction. We need to check
7790 //this values, nevertheless, the difference between the two parametrisations
7791 //is extremely small (way beyond our current precision)
7792 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) +
7794 /(2.);
7795 double muProd1 = muProd -1.0;
7796 double muProd2 = 0.0;
7797
7798 //-- Decay:
7799 double BrHXXRatio = 1.0;
7800 double dBrHXXRatio1 = 0.0;
7801 double dBrHXXRatio2 = 0.0;
7802 if (fstate==0){
7803 // Use for Cross-section [pb] with no Higgs-boson decay
7804 weight = (2.9636); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7805 } else if (fstate == 1){
7806 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7807 dBrHXXRatio1 = BrHXXRatio - 1.0;
7808 dBrHXXRatio2 = 0.0;
7809 } else if (fstate == 2){
7810 BrHXXRatio = (myNPbase->BrHgagaRatio());
7811 dBrHXXRatio1 = BrHXXRatio - 1.0;
7812 dBrHXXRatio2 = 0.0;
7813 } else if (fstate == 3){
7814 BrHXXRatio = (myNPbase->BrHbbRatio());
7815 dBrHXXRatio1 = BrHXXRatio - 1.0;
7816 dBrHXXRatio2 = 0.0;
7817 } else if (fstate == 4){
7818 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7819 dBrHXXRatio1 = BrHXXRatio - 1.0;
7820 dBrHXXRatio2 = 0.0;
7821 } else if (fstate == 5){
7822 BrHXXRatio = (myNPbase->BrHtautauRatio());
7823 dBrHXXRatio1 = BrHXXRatio - 1.0;
7824 dBrHXXRatio2 = 0.0;
7825 } else if (fstate == 6){
7826 BrHXXRatio = (myNPbase->BrHWWRatio());
7827 dBrHXXRatio1 = BrHXXRatio - 1.0;
7828 dBrHXXRatio2 = 0.0;
7829 } else if (fstate == 7){
7830 BrHXXRatio = (myNPbase->BrHZZRatio());
7831 dBrHXXRatio1 = BrHXXRatio - 1.0;
7832 dBrHXXRatio2 = 0.0;
7833 } else {
7834 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
7835 }
7836
7837 //-- Production x Decay:
7838 if ((this->getModel()).isModelLinearized()){
7839 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7840 } else if((this->getModel()).isModelNPquadratic()){
7841 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7842 } else {
7843 return weight*(muProd)*(BrHXXRatio);
7844 }
7845
7846}
7847
7848
7849
7850
7851// -----------------------------------------------------------------------------
7852
7853//AG:STXS2024
7854STXS12_ggH_mjj0_350_pTH120_200_Nj2::STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7855: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7856{
7857 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7858 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
7859
7860}
7861
7863{
7864 //-- Production:
7865 double weight = 1.0; //If normalized to the SM
7867 double muProd1 = muProd -1.0;
7868 double muProd2 = 0.0;
7869
7870 //-- Decay:
7871 double BrHXXRatio = 1.0;
7872 double dBrHXXRatio1 = 0.0;
7873 double dBrHXXRatio2 = 0.0;
7874 if (fstate==0){
7875 // Use for Cross-section [pb] with no Higgs-boson decay
7876 weight = 0.94325; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7877 } else if (fstate == 1){
7878 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7879 dBrHXXRatio1 = BrHXXRatio - 1.0;
7880 dBrHXXRatio2 = 0.0;
7881 } else if (fstate == 2){
7882 BrHXXRatio = (myNPbase->BrHgagaRatio());
7883 dBrHXXRatio1 = BrHXXRatio - 1.0;
7884 dBrHXXRatio2 = 0.0;
7885 } else if (fstate == 3){
7886 BrHXXRatio = (myNPbase->BrHbbRatio());
7887 dBrHXXRatio1 = BrHXXRatio - 1.0;
7888 dBrHXXRatio2 = 0.0;
7889 } else if (fstate == 4){
7890 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7891 dBrHXXRatio1 = BrHXXRatio - 1.0;
7892 dBrHXXRatio2 = 0.0;
7893 } else if (fstate == 5){
7894 BrHXXRatio = (myNPbase->BrHtautauRatio());
7895 dBrHXXRatio1 = BrHXXRatio - 1.0;
7896 dBrHXXRatio2 = 0.0;
7897 }else {
7898 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
7899 }
7900
7901 //-- Production x Decay:
7902 if ((this->getModel()).isModelLinearized()){
7903 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7904 } else if((this->getModel()).isModelNPquadratic()){
7905 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7906 } else {
7907 return weight*(muProd)*(BrHXXRatio);
7908 }
7909
7910}
7911
7912
7913
7914
7915//VM:STXS2024;
7916STXS12_ggH_mjj350_Inf_pTH0_200_Nj2::STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7917: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7918{
7919 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7920 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
7921
7922}
7923
7925{
7926 //-- Production:
7927 double weight = 1.0; //If normalized to the SM
7928 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7929 //We should weight each xsection with the SM prediction. We need to check
7930 //this values, nevertheless, the difference between the two parametrisations
7931 //is extremely small (way beyond our current precision)
7934 /(2.);
7935 double muProd1 = muProd -1.0;
7936 double muProd2 = 0.0;
7937
7938 //-- Decay:
7939 double BrHXXRatio = 1.0;
7940 double dBrHXXRatio1 = 0.0;
7941 double dBrHXXRatio2 = 0.0;
7942 if (fstate==0){
7943 // Use for Cross-section [pb] with no Higgs-boson decay
7944 weight = (0.92136); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7945 } else if (fstate == 1){
7946 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7947 dBrHXXRatio1 = BrHXXRatio - 1.0;
7948 dBrHXXRatio2 = 0.0;
7949 } else if (fstate == 2){
7950 BrHXXRatio = (myNPbase->BrHgagaRatio());
7951 dBrHXXRatio1 = BrHXXRatio - 1.0;
7952 dBrHXXRatio2 = 0.0;
7953 } else if (fstate == 3){
7954 BrHXXRatio = (myNPbase->BrHbbRatio());
7955 dBrHXXRatio1 = BrHXXRatio - 1.0;
7956 dBrHXXRatio2 = 0.0;
7957 } else if (fstate == 4){
7958 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7959 dBrHXXRatio1 = BrHXXRatio - 1.0;
7960 dBrHXXRatio2 = 0.0;
7961 } else if (fstate == 5){
7962 BrHXXRatio = (myNPbase->BrHtautauRatio());
7963 dBrHXXRatio1 = BrHXXRatio - 1.0;
7964 dBrHXXRatio2 = 0.0;
7965 } else if (fstate == 6){
7966 BrHXXRatio = (myNPbase->BrHWWRatio());
7967 dBrHXXRatio1 = BrHXXRatio - 1.0;
7968 dBrHXXRatio2 = 0.0;
7969 } else if (fstate == 7){
7970 BrHXXRatio = (myNPbase->BrHZZRatio());
7971 dBrHXXRatio1 = BrHXXRatio - 1.0;
7972 dBrHXXRatio2 = 0.0;
7973 } else {
7974 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
7975 }
7976
7977 //-- Production x Decay:
7978 if ((this->getModel()).isModelLinearized()){
7979 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7980 } else if((this->getModel()).isModelNPquadratic()){
7981 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7982 } else {
7983 return weight*(muProd)*(BrHXXRatio);
7984 }
7985
7986}
7987
7988
7989// -----------------------------------------------------------------------------
7990
7992: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7993{
7994 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7995 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
7996
7997}
7998
8000{
8001 double BrHXXRatio = 1.0;
8002 if (fstate == 1){
8003 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8004 } else if (fstate == 2){
8005 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8006 } else if (fstate == 3){
8007 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8008 } else if (fstate == 4){
8009 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8010 } else {
8011 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8012 }
8013
8014 if ((this->getModel()).isModelLinearized()) {
8015 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8016 } else {
8018 }
8019}
8020
8021// -----------------------------------------------------------------------------
8022
8024: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8025{
8026
8027 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8028 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8029
8030}
8031
8033{
8034 double BrHXXRatio = 1.0;
8035 if (fstate == 1){
8036 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8037 } else if (fstate == 2){
8038 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8039 } else if (fstate == 3){
8040 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8041 } else if (fstate == 4){
8042 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8043 } else {
8044 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8045 }
8046
8047 if ((this->getModel()).isModelLinearized()) {
8048 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8049 } else {
8051 }
8052}
8053
8054// -----------------------------------------------------------------------------
8055
8057: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8058{
8059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8060 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8061
8062}
8063
8065{
8066 double BrHXXRatio = 1.0;
8067 if (fstate == 1){
8068 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8069 } else if (fstate == 2){
8070 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8071 } else if (fstate == 3){
8072 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8073 } else if (fstate == 4){
8074 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8075 } else {
8076 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8077 }
8078
8079 if ((this->getModel()).isModelLinearized()) {
8080 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8081 } else {
8083 }
8084}
8085
8086// -----------------------------------------------------------------------------
8087
8089: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8090{
8091 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8092 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8093
8094}
8095
8097{
8098 double BrHXXRatio = 1.0;
8099 if (fstate == 1){
8100 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8101 } else if (fstate == 2){
8102 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8103 } else if (fstate == 3){
8104 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8105 } else if (fstate == 4){
8106 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8107 } else {
8108 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8109 }
8110
8111 if ((this->getModel()).isModelLinearized()) {
8112 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8113 } else {
8115 }
8116}
8117
8118
8119
8120
8121
8122// -----------------------------------------------------------------------------
8123
8124//VM:STXS2024;
8125STXS12_ggH_pTH0_200_Nj2::STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8126: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8127{
8128 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8129 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8130
8131}
8132
8134{
8135
8136
8137
8138 //-- Production:
8139 double weight = 1.0; //If normalized to the SM
8140 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8141 //VM: In the reference above we have the SM predictions for less bins. Angelica should have
8142 //the ones for Madgraph and we could use those. In any case the parametrisation is very stable
8143 //we give the same weight to the bins for which we don't have the SM prediction (for the moment)!
8144 //The possible error that we could be introducing here is way below our precision!
8145 double muProd = (
8149 )/(2.9636+0.94321+0.87751);
8150 double muProd1 = muProd -1.0;
8151 double muProd2 = 0.0;
8152
8153 //-- Decay:
8154 double BrHXXRatio = 1.0;
8155 double dBrHXXRatio1 = 0.0;
8156 double dBrHXXRatio2 = 0.0;
8157 if (fstate==0){
8158 // Use for Cross-section [pb] with no Higgs-boson decay
8159 weight = (2.9636+0.94321+0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8160 } else if (fstate == 1){
8161 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8162 dBrHXXRatio1 = BrHXXRatio - 1.0;
8163 dBrHXXRatio2 = 0.0;
8164 } else if (fstate == 2){
8165 BrHXXRatio = (myNPbase->BrHgagaRatio());
8166 dBrHXXRatio1 = BrHXXRatio - 1.0;
8167 dBrHXXRatio2 = 0.0;
8168 } else if (fstate == 3){
8169 BrHXXRatio = (myNPbase->BrHbbRatio());
8170 dBrHXXRatio1 = BrHXXRatio - 1.0;
8171 dBrHXXRatio2 = 0.0;
8172 } else if (fstate == 4){
8173 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8174 dBrHXXRatio1 = BrHXXRatio - 1.0;
8175 dBrHXXRatio2 = 0.0;
8176 } else if (fstate == 5){
8177 BrHXXRatio = (myNPbase->BrHtautauRatio());
8178 dBrHXXRatio1 = BrHXXRatio - 1.0;
8179 dBrHXXRatio2 = 0.0;
8180 } else if (fstate == 6){
8181 BrHXXRatio = (myNPbase->BrHWWRatio());
8182 dBrHXXRatio1 = BrHXXRatio - 1.0;
8183 dBrHXXRatio2 = 0.0;
8184 } else if (fstate == 7){
8185 BrHXXRatio = (myNPbase->BrHZZRatio());
8186 dBrHXXRatio1 = BrHXXRatio - 1.0;
8187 dBrHXXRatio2 = 0.0;
8188 } else {
8189 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8190 }
8191
8192 //-- Production x Decay:
8193 if ((this->getModel()).isModelLinearized()){
8194 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8195 } else if((this->getModel()).isModelNPquadratic()){
8196 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8197 } else {
8198 return weight*(muProd)*(BrHXXRatio);
8199 }
8200
8201}
8202
8203
8204
8205
8206
8207
8208
8209// -----------------------------------------------------------------------------
8210
8211
8212//VM:STXS2024;
8213STXS12_ggH_pTH200_Inf::STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8214: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8215{
8216 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8217 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8218
8219}
8220
8222{
8223 //-- Production:
8224 double weight = 1.0; //If normalized to the SM
8225 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8226 double muProd = ( 0.45825*(myNPbase->STXS12_ggH_pTH200_300(sqrt_s)) +
8229 /(0.45825 + 0.10632 + 0.017974);
8230 double muProd1 = muProd -1.0;
8231 double muProd2 = 0.0;
8232
8233 //-- Decay:
8234 double BrHXXRatio = 1.0;
8235 double dBrHXXRatio1 = 0.0;
8236 double dBrHXXRatio2 = 0.0;
8237 if (fstate==0){
8238 // Use for Cross-section [pb] with no Higgs-boson decay
8239 weight = (0.45825 + 0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8240 } else if (fstate == 1){
8241 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8242 dBrHXXRatio1 = BrHXXRatio - 1.0;
8243 dBrHXXRatio2 = 0.0;
8244 } else if (fstate == 2){
8245 BrHXXRatio = (myNPbase->BrHgagaRatio());
8246 dBrHXXRatio1 = BrHXXRatio - 1.0;
8247 dBrHXXRatio2 = 0.0;
8248 } else if (fstate == 3){
8249 BrHXXRatio = (myNPbase->BrHbbRatio());
8250 dBrHXXRatio1 = BrHXXRatio - 1.0;
8251 dBrHXXRatio2 = 0.0;
8252 } else if (fstate == 4){
8253 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8254 dBrHXXRatio1 = BrHXXRatio - 1.0;
8255 dBrHXXRatio2 = 0.0;
8256 } else if (fstate == 5){
8257 BrHXXRatio = (myNPbase->BrHtautauRatio());
8258 dBrHXXRatio1 = BrHXXRatio - 1.0;
8259 dBrHXXRatio2 = 0.0;
8260 } else if (fstate == 6){
8261 BrHXXRatio = (myNPbase->BrHWWRatio());
8262 dBrHXXRatio1 = BrHXXRatio - 1.0;
8263 dBrHXXRatio2 = 0.0;
8264 } else if (fstate == 7){
8265 BrHXXRatio = (myNPbase->BrHZZRatio());
8266 dBrHXXRatio1 = BrHXXRatio - 1.0;
8267 dBrHXXRatio2 = 0.0;
8268 } else {
8269 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8270 }
8271
8272 //-- Production x Decay:
8273 if ((this->getModel()).isModelLinearized()){
8274 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8275 } else if((this->getModel()).isModelNPquadratic()){
8276 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8277 } else {
8278 return weight*(muProd)*(BrHXXRatio);
8279 }
8280
8281}
8282
8283
8284
8285
8286// -----------------------------------------------------------------------------
8287
8288
8289//VM:STXS2024;
8290STXS12_ggH_pTH300_Inf::STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8291: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8292{
8293 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8294 throw std::runtime_error("STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8295
8296}
8297
8299{
8300 //-- Production:
8301 double weight = 1.0; //If normalized to the SM
8302 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8303 double muProd = (0.10632*(myNPbase->STXS12_ggH_pTH300_450(sqrt_s)) +
8305 /(0.10632 + 0.017974);
8306 double muProd1 = muProd -1.0;
8307 double muProd2 = 0.0;
8308
8309 //-- Decay:
8310 double BrHXXRatio = 1.0;
8311 double dBrHXXRatio1 = 0.0;
8312 double dBrHXXRatio2 = 0.0;
8313 if (fstate==0){
8314 // Use for Cross-section [pb] with no Higgs-boson decay
8315 weight = (0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8316 } else if (fstate == 1){
8317 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8318 dBrHXXRatio1 = BrHXXRatio - 1.0;
8319 dBrHXXRatio2 = 0.0;
8320 } else if (fstate == 2){
8321 BrHXXRatio = (myNPbase->BrHgagaRatio());
8322 dBrHXXRatio1 = BrHXXRatio - 1.0;
8323 dBrHXXRatio2 = 0.0;
8324 } else if (fstate == 3){
8325 BrHXXRatio = (myNPbase->BrHbbRatio());
8326 dBrHXXRatio1 = BrHXXRatio - 1.0;
8327 dBrHXXRatio2 = 0.0;
8328 } else if (fstate == 4){
8329 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8330 dBrHXXRatio1 = BrHXXRatio - 1.0;
8331 dBrHXXRatio2 = 0.0;
8332 } else if (fstate == 5){
8333 BrHXXRatio = (myNPbase->BrHtautauRatio());
8334 dBrHXXRatio1 = BrHXXRatio - 1.0;
8335 dBrHXXRatio2 = 0.0;
8336 } else if (fstate == 6){
8337 BrHXXRatio = (myNPbase->BrHWWRatio());
8338 dBrHXXRatio1 = BrHXXRatio - 1.0;
8339 dBrHXXRatio2 = 0.0;
8340 } else if (fstate == 7){
8341 BrHXXRatio = (myNPbase->BrHZZRatio());
8342 dBrHXXRatio1 = BrHXXRatio - 1.0;
8343 dBrHXXRatio2 = 0.0;
8344 } else {
8345 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8346 }
8347
8348 //-- Production x Decay:
8349 if ((this->getModel()).isModelLinearized()){
8350 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8351 } else if((this->getModel()).isModelNPquadratic()){
8352 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8353 } else {
8354 return weight*(muProd)*(BrHXXRatio);
8355 }
8356
8357}
8358
8359
8360// -----------------------------------------------------------------------------
8361
8362
8363//VM:STXS2024;
8364STXS12_ggH_pTH200_300::STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8365: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8366{
8367 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8368 throw std::runtime_error("STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8369
8370}
8371
8373{
8374 //-- Production:
8375 double weight = 1.0; //If normalized to the SM
8376 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8377 double muProd = myNPbase->STXS12_ggH_pTH200_300(sqrt_s);
8378 double muProd1 = muProd -1.0;
8379 double muProd2 = 0.0;
8380
8381 //-- Decay:
8382 double BrHXXRatio = 1.0;
8383 double dBrHXXRatio1 = 0.0;
8384 double dBrHXXRatio2 = 0.0;
8385 if (fstate==0){
8386 // Use for Cross-section [pb] with no Higgs-boson decay
8387 weight = (0.45825 ); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8388 } else if (fstate == 1){
8389 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8390 dBrHXXRatio1 = BrHXXRatio - 1.0;
8391 dBrHXXRatio2 = 0.0;
8392 } else if (fstate == 2){
8393 BrHXXRatio = (myNPbase->BrHgagaRatio());
8394 dBrHXXRatio1 = BrHXXRatio - 1.0;
8395 dBrHXXRatio2 = 0.0;
8396 } else if (fstate == 3){
8397 BrHXXRatio = (myNPbase->BrHbbRatio());
8398 dBrHXXRatio1 = BrHXXRatio - 1.0;
8399 dBrHXXRatio2 = 0.0;
8400 } else if (fstate == 4){
8401 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8402 dBrHXXRatio1 = BrHXXRatio - 1.0;
8403 dBrHXXRatio2 = 0.0;
8404 } else if (fstate == 5){
8405 BrHXXRatio = (myNPbase->BrHtautauRatio());
8406 dBrHXXRatio1 = BrHXXRatio - 1.0;
8407 dBrHXXRatio2 = 0.0;
8408 } else if (fstate == 6){
8409 BrHXXRatio = (myNPbase->BrHWWRatio());
8410 dBrHXXRatio1 = BrHXXRatio - 1.0;
8411 dBrHXXRatio2 = 0.0;
8412 } else if (fstate == 7){
8413 BrHXXRatio = (myNPbase->BrHZZRatio());
8414 dBrHXXRatio1 = BrHXXRatio - 1.0;
8415 dBrHXXRatio2 = 0.0;
8416 } else {
8417 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8418 }
8419
8420 //-- Production x Decay:
8421 if ((this->getModel()).isModelLinearized()){
8422 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8423 } else if((this->getModel()).isModelNPquadratic()){
8424 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8425 } else {
8426 return weight*(muProd)*(BrHXXRatio);
8427 }
8428
8429}
8430
8431
8432
8433// -----------------------------------------------------------------------------
8434
8435
8436//VM:STXS2024;
8437STXS12_ggH_pTH300_450::STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8438: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8439{
8440 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8441 throw std::runtime_error("STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8442
8443}
8444
8446{
8447 //-- Production:
8448 double weight = 1.0; //If normalized to the SM
8449 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8450 double muProd = myNPbase->STXS12_ggH_pTH300_450(sqrt_s);
8451 double muProd1 = muProd -1.0;
8452 double muProd2 = 0.0;
8453
8454 //-- Decay:
8455 double BrHXXRatio = 1.0;
8456 double dBrHXXRatio1 = 0.0;
8457 double dBrHXXRatio2 = 0.0;
8458 if (fstate==0){
8459 // Use for Cross-section [pb] with no Higgs-boson decay
8460 weight = 0.10632; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8461 } else if (fstate == 1){
8462 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8463 dBrHXXRatio1 = BrHXXRatio - 1.0;
8464 dBrHXXRatio2 = 0.0;
8465 } else if (fstate == 2){
8466 BrHXXRatio = (myNPbase->BrHgagaRatio());
8467 dBrHXXRatio1 = BrHXXRatio - 1.0;
8468 dBrHXXRatio2 = 0.0;
8469 } else if (fstate == 3){
8470 BrHXXRatio = (myNPbase->BrHbbRatio());
8471 dBrHXXRatio1 = BrHXXRatio - 1.0;
8472 dBrHXXRatio2 = 0.0;
8473 } else if (fstate == 4){
8474 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8475 dBrHXXRatio1 = BrHXXRatio - 1.0;
8476 dBrHXXRatio2 = 0.0;
8477 } else if (fstate == 5){
8478 BrHXXRatio = (myNPbase->BrHtautauRatio());
8479 dBrHXXRatio1 = BrHXXRatio - 1.0;
8480 dBrHXXRatio2 = 0.0;
8481 } else if (fstate == 6){
8482 BrHXXRatio = (myNPbase->BrHWWRatio());
8483 dBrHXXRatio1 = BrHXXRatio - 1.0;
8484 dBrHXXRatio2 = 0.0;
8485 } else if (fstate == 7){
8486 BrHXXRatio = (myNPbase->BrHZZRatio());
8487 dBrHXXRatio1 = BrHXXRatio - 1.0;
8488 dBrHXXRatio2 = 0.0;
8489 } else {
8490 throw std::runtime_error("STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8491 }
8492
8493 //-- Production x Decay:
8494 if ((this->getModel()).isModelLinearized()){
8495 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8496 } else if((this->getModel()).isModelNPquadratic()){
8497 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8498 } else {
8499 return weight*(muProd)*(BrHXXRatio);
8500 }
8501
8502}
8503
8504
8505
8506
8507// -----------------------------------------------------------------------------
8508
8509
8510//VM:STXS2024;
8511STXS12_ggH_pTH450_650::STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8512: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8513{
8514 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8515 throw std::runtime_error("STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8516
8517}
8518
8520{
8521 //-- Production:
8522 double weight = 1.0; //If normalized to the SM
8523 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8524 double muProd = myNPbase->STXS12_ggH_pTH450_650(sqrt_s);
8525 double muProd1 = muProd -1.0;
8526 double muProd2 = 0.0;
8527
8528 //-- Decay:
8529 double BrHXXRatio = 1.0;
8530 double dBrHXXRatio1 = 0.0;
8531 double dBrHXXRatio2 = 0.0;
8532 if (fstate==0){
8533 // Use for Cross-section [pb] with no Higgs-boson decay
8534 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8535 } else if (fstate == 1){
8536 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8537 dBrHXXRatio1 = BrHXXRatio - 1.0;
8538 dBrHXXRatio2 = 0.0;
8539 } else if (fstate == 2){
8540 BrHXXRatio = (myNPbase->BrHgagaRatio());
8541 dBrHXXRatio1 = BrHXXRatio - 1.0;
8542 dBrHXXRatio2 = 0.0;
8543 } else if (fstate == 3){
8544 BrHXXRatio = (myNPbase->BrHbbRatio());
8545 dBrHXXRatio1 = BrHXXRatio - 1.0;
8546 dBrHXXRatio2 = 0.0;
8547 } else if (fstate == 4){
8548 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8549 dBrHXXRatio1 = BrHXXRatio - 1.0;
8550 dBrHXXRatio2 = 0.0;
8551 } else if (fstate == 5){
8552 BrHXXRatio = (myNPbase->BrHtautauRatio());
8553 dBrHXXRatio1 = BrHXXRatio - 1.0;
8554 dBrHXXRatio2 = 0.0;
8555 } else if (fstate == 6){
8556 BrHXXRatio = (myNPbase->BrHWWRatio());
8557 dBrHXXRatio1 = BrHXXRatio - 1.0;
8558 dBrHXXRatio2 = 0.0;
8559 } else if (fstate == 7){
8560 BrHXXRatio = (myNPbase->BrHZZRatio());
8561 dBrHXXRatio1 = BrHXXRatio - 1.0;
8562 dBrHXXRatio2 = 0.0;
8563 } else {
8564 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8565 }
8566
8567 //-- Production x Decay:
8568 if ((this->getModel()).isModelLinearized()){
8569 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8570 } else if((this->getModel()).isModelNPquadratic()){
8571 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8572 } else {
8573 return weight*(muProd)*(BrHXXRatio);
8574 }
8575
8576}
8577
8578
8579
8580// -----------------------------------------------------------------------------
8581
8582
8583//VM:STXS2024;
8584STXS12_ggH_pTH650_Inf::STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8585: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8586{
8587 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8588 throw std::runtime_error("STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8589
8590}
8591
8593{
8594 //-- Production:
8595 double weight = 1.0; //If normalized to the SM
8596 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8597 double muProd = myNPbase->STXS12_ggH_pTH650_Inf(sqrt_s);
8598 double muProd1 = muProd -1.0;
8599 double muProd2 = 0.0;
8600
8601 //-- Decay:
8602 double BrHXXRatio = 1.0;
8603 double dBrHXXRatio1 = 0.0;
8604 double dBrHXXRatio2 = 0.0;
8605 if (fstate==0){
8606 // Use for Cross-section [pb] with no Higgs-boson decay
8607 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8608 } else if (fstate == 1){
8609 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8610 dBrHXXRatio1 = BrHXXRatio - 1.0;
8611 dBrHXXRatio2 = 0.0;
8612 } else if (fstate == 2){
8613 BrHXXRatio = (myNPbase->BrHgagaRatio());
8614 dBrHXXRatio1 = BrHXXRatio - 1.0;
8615 dBrHXXRatio2 = 0.0;
8616 } else if (fstate == 3){
8617 BrHXXRatio = (myNPbase->BrHbbRatio());
8618 dBrHXXRatio1 = BrHXXRatio - 1.0;
8619 dBrHXXRatio2 = 0.0;
8620 } else if (fstate == 4){
8621 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8622 dBrHXXRatio1 = BrHXXRatio - 1.0;
8623 dBrHXXRatio2 = 0.0;
8624 } else if (fstate == 5){
8625 BrHXXRatio = (myNPbase->BrHtautauRatio());
8626 dBrHXXRatio1 = BrHXXRatio - 1.0;
8627 dBrHXXRatio2 = 0.0;
8628 } else if (fstate == 6){
8629 BrHXXRatio = (myNPbase->BrHWWRatio());
8630 dBrHXXRatio1 = BrHXXRatio - 1.0;
8631 dBrHXXRatio2 = 0.0;
8632 } else if (fstate == 7){
8633 BrHXXRatio = (myNPbase->BrHZZRatio());
8634 dBrHXXRatio1 = BrHXXRatio - 1.0;
8635 dBrHXXRatio2 = 0.0;
8636 } else {
8637 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8638 }
8639
8640 //-- Production x Decay:
8641 if ((this->getModel()).isModelLinearized()){
8642 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8643 } else if((this->getModel()).isModelNPquadratic()){
8644 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8645 } else {
8646 return weight*(muProd)*(BrHXXRatio);
8647 }
8648
8649}
8650
8651
8652
8653// -----------------------------------------------------------------------------
8654
8655
8656//VM:STXS2024;
8657STXS12_ggH_pTH450_Inf::STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8658: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8659{
8660 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8661 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8662
8663}
8664
8666{
8667 //-- Production:
8668 double weight = 1.0; //If normalized to the SM
8669 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8670 double muProd = myNPbase->STXS12_ggH_pTH450_Inf(sqrt_s);
8671 double muProd1 = muProd -1.0;
8672 double muProd2 = 0.0;
8673
8674 //-- Decay:
8675 double BrHXXRatio = 1.0;
8676 double dBrHXXRatio1 = 0.0;
8677 double dBrHXXRatio2 = 0.0;
8678 if (fstate==0){
8679 // Use for Cross-section [pb] with no Higgs-boson decay
8680 weight = 0.017974; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8681 } else if (fstate == 1){
8682 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8683 dBrHXXRatio1 = BrHXXRatio - 1.0;
8684 dBrHXXRatio2 = 0.0;
8685 } else if (fstate == 2){
8686 BrHXXRatio = (myNPbase->BrHgagaRatio());
8687 dBrHXXRatio1 = BrHXXRatio - 1.0;
8688 dBrHXXRatio2 = 0.0;
8689 } else if (fstate == 3){
8690 BrHXXRatio = (myNPbase->BrHbbRatio());
8691 dBrHXXRatio1 = BrHXXRatio - 1.0;
8692 dBrHXXRatio2 = 0.0;
8693 } else if (fstate == 4){
8694 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8695 dBrHXXRatio1 = BrHXXRatio - 1.0;
8696 dBrHXXRatio2 = 0.0;
8697 } else if (fstate == 5){
8698 BrHXXRatio = (myNPbase->BrHtautauRatio());
8699 dBrHXXRatio1 = BrHXXRatio - 1.0;
8700 dBrHXXRatio2 = 0.0;
8701 } else if (fstate == 6){
8702 BrHXXRatio = (myNPbase->BrHWWRatio());
8703 dBrHXXRatio1 = BrHXXRatio - 1.0;
8704 dBrHXXRatio2 = 0.0;
8705 } else if (fstate == 7){
8706 BrHXXRatio = (myNPbase->BrHZZRatio());
8707 dBrHXXRatio1 = BrHXXRatio - 1.0;
8708 dBrHXXRatio2 = 0.0;
8709 } else {
8710 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8711 }
8712
8713 //-- Production x Decay:
8714 if ((this->getModel()).isModelLinearized()){
8715 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8716 } else if((this->getModel()).isModelNPquadratic()){
8717 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8718 } else {
8719 return weight*(muProd)*(BrHXXRatio);
8720 }
8721
8722}
8723
8724
8725// -----------------------------------------------------------------------------
8726
8727STXS12_ggHll_pTV0_75::STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8728: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8729{
8730 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8731 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
8732
8733}
8734
8736{
8737 double BrHXXRatio = 1.0;
8738 if (fstate == 1){
8739 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8740 } else if (fstate == 2){
8741 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8742 } else if (fstate == 3){
8743 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8744 } else if (fstate == 4){
8745 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8746 } else {
8747 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
8748 }
8749
8750 if ((this->getModel()).isModelLinearized()) {
8751 return ((myNPbase->STXS12_ggHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
8752 } else {
8753 return (myNPbase->STXS12_ggHll_pTV0_75(sqrt_s))*(BrHXXRatio);
8754 }
8755}
8756
8757// -----------------------------------------------------------------------------
8758
8759STXS12_ggHll_pTV75_150::STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8760: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8761{
8762 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8763 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
8764
8765}
8766
8768{
8769 double BrHXXRatio = 1.0;
8770 if (fstate == 1){
8771 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8772 } else if (fstate == 2){
8773 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8774 } else if (fstate == 3){
8775 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8776 } else if (fstate == 4){
8777 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8778 } else {
8779 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
8780 }
8781
8782 if ((this->getModel()).isModelLinearized()) {
8783 return ((myNPbase->STXS12_ggHll_pTV75_150(sqrt_s)) + (BrHXXRatio) - 1.0);
8784 } else {
8785 return (myNPbase->STXS12_ggHll_pTV75_150(sqrt_s))*(BrHXXRatio);
8786 }
8787}
8788
8789// -----------------------------------------------------------------------------
8790
8791STXS12_ggHll_pTV150_250_Nj0::STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8792: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8793{
8794 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8795 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
8796
8797}
8798
8800{
8801 double BrHXXRatio = 1.0;
8802 if (fstate == 1){
8803 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8804 } else if (fstate == 2){
8805 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8806 } else if (fstate == 3){
8807 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8808 } else if (fstate == 4){
8809 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8810 } else {
8811 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
8812 }
8813
8814 if ((this->getModel()).isModelLinearized()) {
8815 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8816 } else {
8817 return (myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s))*(BrHXXRatio);
8818 }
8819}
8820
8821// -----------------------------------------------------------------------------
8822
8823STXS12_ggHll_pTV150_250_Nj1::STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8824: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8825{
8826 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8827 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
8828
8829}
8830
8832{
8833 double BrHXXRatio = 1.0;
8834 if (fstate == 1){
8835 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8836 } else if (fstate == 2){
8837 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8838 } else if (fstate == 3){
8839 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8840 } else if (fstate == 4){
8841 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8842 } else {
8843 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
8844 }
8845
8846 if ((this->getModel()).isModelLinearized()) {
8847 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8848 } else {
8849 return (myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
8850 }
8851}
8852
8853// -----------------------------------------------------------------------------
8854
8855STXS12_ggHll_pTV250_Inf::STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8856: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8857{
8858 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8859 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
8860
8861}
8862
8864{
8865 double BrHXXRatio = 1.0;
8866 if (fstate == 1){
8867 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8868 } else if (fstate == 2){
8869 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8870 } else if (fstate == 3){
8871 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8872 } else if (fstate == 4){
8873 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8874 } else {
8875 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
8876 }
8877
8878 if ((this->getModel()).isModelLinearized()) {
8879 return ((myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
8880 } else {
8881 return (myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
8882 }
8883}
8884
8885// -----------------------------------------------------------------------------
8886
8887STXS12_qqHqq_Nj0::STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8888: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8889{
8890 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8891 throw std::runtime_error("STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
8892
8893}
8894
8896{
8897 double BrHXXRatio = 1.0;
8898 if (fstate == 1){
8899 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8900 } else if (fstate == 2){
8901 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8902 } else if (fstate == 3){
8903 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8904 } else if (fstate == 4){
8905 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8906 } else {
8907 throw std::runtime_error("STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
8908 }
8909
8910 if ((this->getModel()).isModelLinearized()) {
8911 return ((myNPbase->STXS12_qqHqq_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8912 } else {
8913 return (myNPbase->STXS12_qqHqq_Nj0(sqrt_s))*(BrHXXRatio);
8914 }
8915}
8916
8917// -----------------------------------------------------------------------------
8918
8919STXS12_qqHqq_Nj1::STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8920: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8921{
8922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8923 throw std::runtime_error("STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
8924
8925}
8926
8928{
8929 double BrHXXRatio = 1.0;
8930 if (fstate == 1){
8931 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8932 } else if (fstate == 2){
8933 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8934 } else if (fstate == 3){
8935 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8936 } else if (fstate == 4){
8937 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8938 } else {
8939 throw std::runtime_error("STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
8940 }
8941
8942 if ((this->getModel()).isModelLinearized()) {
8943 return ((myNPbase->STXS12_qqHqq_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8944 } else {
8945 return (myNPbase->STXS12_qqHqq_Nj1(sqrt_s))*(BrHXXRatio);
8946 }
8947}
8948
8949// -----------------------------------------------------------------------------
8950
8951STXS12_qqHqq_mjj0_60_Nj2::STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8952: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8953{
8954 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8955 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
8956
8957}
8958
8960{
8961 double BrHXXRatio = 1.0;
8962 if (fstate == 1){
8963 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8964 } else if (fstate == 2){
8965 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8966 } else if (fstate == 3){
8967 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8968 } else if (fstate == 4){
8969 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8970 } else {
8971 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
8972 }
8973
8974 if ((this->getModel()).isModelLinearized()) {
8975 return ((myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8976 } else {
8977 return (myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s))*(BrHXXRatio);
8978 }
8979}
8980
8981
8982
8983// -----------------------------------------------------------------------------
8984
8985
8986//VM:STXS2024;
8987STXS12_qqHqq_VH_veto_Nj01::STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8988: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8989{
8990 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8991 throw std::runtime_error("STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
8992
8993}
8994
8996{
8997 //-- Production:
8998 double weight = 1.0; //If normalized to the SM
8999 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9000 double muProd = myNPbase->STXS12_qqHqq_VH_veto_Nj01(sqrt_s);
9001 double muProd1 = muProd -1.0;
9002 double muProd2 = 0.0;
9003
9004 //-- Decay:
9005 double BrHXXRatio = 1.0;
9006 double dBrHXXRatio1 = 0.0;
9007 double dBrHXXRatio2 = 0.0;
9008 if (fstate==0){
9009 // Use for Cross-section [pb] with no Higgs-boson decay
9010 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9011 } else if (fstate == 1){
9012 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9013 dBrHXXRatio1 = BrHXXRatio - 1.0;
9014 dBrHXXRatio2 = 0.0;
9015 } else if (fstate == 2){
9016 BrHXXRatio = (myNPbase->BrHgagaRatio());
9017 dBrHXXRatio1 = BrHXXRatio - 1.0;
9018 dBrHXXRatio2 = 0.0;
9019 } else if (fstate == 3){
9020 BrHXXRatio = (myNPbase->BrHbbRatio());
9021 dBrHXXRatio1 = BrHXXRatio - 1.0;
9022 dBrHXXRatio2 = 0.0;
9023 } else if (fstate == 4){
9024 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9025 dBrHXXRatio1 = BrHXXRatio - 1.0;
9026 dBrHXXRatio2 = 0.0;
9027 } else if (fstate == 5){
9028 BrHXXRatio = (myNPbase->BrHtautauRatio());
9029 dBrHXXRatio1 = BrHXXRatio - 1.0;
9030 dBrHXXRatio2 = 0.0;
9031 } else if (fstate == 6){
9032 BrHXXRatio = (myNPbase->BrHWWRatio());
9033 dBrHXXRatio1 = BrHXXRatio - 1.0;
9034 dBrHXXRatio2 = 0.0;
9035 } else if (fstate == 7){
9036 BrHXXRatio = (myNPbase->BrHZZRatio());
9037 dBrHXXRatio1 = BrHXXRatio - 1.0;
9038 dBrHXXRatio2 = 0.0;
9039 } else {
9040 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9041 }
9042
9043 //-- Production x Decay:
9044 if ((this->getModel()).isModelLinearized()){
9045 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9046 } else if((this->getModel()).isModelNPquadratic()){
9047 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9048 } else {
9049 return weight*(muProd)*(BrHXXRatio);
9050 }
9051
9052}
9053
9054
9055
9056
9057// -----------------------------------------------------------------------------
9058
9059
9060//VM:STXS2024;
9061STXS12_qqHqq_VH_had_Nj2::STXS12_qqHqq_VH_had_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9062: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9063{
9064 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9065 throw std::runtime_error("STXS12_qqHqq_VH_had_Nj2 called with a class whose parent is not NPbase");
9066
9067}
9068
9070{
9071 //-- Production:
9072 double weight = 1.0; //If normalized to the SM
9073 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9074 double muProd = myNPbase->STXS12_qqHqq_VH_had_Nj2(sqrt_s);
9075 double muProd1 = muProd -1.0;
9076 double muProd2 = 0.0;
9077
9078 //-- Decay:
9079 double BrHXXRatio = 1.0;
9080 double dBrHXXRatio1 = 0.0;
9081 double dBrHXXRatio2 = 0.0;
9082 if (fstate==0){
9083 // Use for Cross-section [pb] with no Higgs-boson decay
9084 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9085 } else if (fstate == 1){
9086 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9087 dBrHXXRatio1 = BrHXXRatio - 1.0;
9088 dBrHXXRatio2 = 0.0;
9089 } else if (fstate == 2){
9090 BrHXXRatio = (myNPbase->BrHgagaRatio());
9091 dBrHXXRatio1 = BrHXXRatio - 1.0;
9092 dBrHXXRatio2 = 0.0;
9093 } else if (fstate == 3){
9094 BrHXXRatio = (myNPbase->BrHbbRatio());
9095 dBrHXXRatio1 = BrHXXRatio - 1.0;
9096 dBrHXXRatio2 = 0.0;
9097 } else if (fstate == 4){
9098 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9099 dBrHXXRatio1 = BrHXXRatio - 1.0;
9100 dBrHXXRatio2 = 0.0;
9101 } else if (fstate == 5){
9102 BrHXXRatio = (myNPbase->BrHtautauRatio());
9103 dBrHXXRatio1 = BrHXXRatio - 1.0;
9104 dBrHXXRatio2 = 0.0;
9105 } else if (fstate == 6){
9106 BrHXXRatio = (myNPbase->BrHWWRatio());
9107 dBrHXXRatio1 = BrHXXRatio - 1.0;
9108 dBrHXXRatio2 = 0.0;
9109 } else if (fstate == 7){
9110 BrHXXRatio = (myNPbase->BrHZZRatio());
9111 dBrHXXRatio1 = BrHXXRatio - 1.0;
9112 dBrHXXRatio2 = 0.0;
9113 } else {
9114 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9115 }
9116
9117 //-- Production x Decay:
9118 if ((this->getModel()).isModelLinearized()){
9119 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9120 } else if((this->getModel()).isModelNPquadratic()){
9121 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9122 } else {
9123 return weight*(muProd)*(BrHXXRatio);
9124 }
9125
9126}
9127
9128
9129
9130// -----------------------------------------------------------------------------
9131
9132//AG:STXS2024
9133STXS12_qqHqq_mjj60_120_Nj2::STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9134: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9135{
9136 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9137 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9138
9139}
9140
9142{
9143 //-- Production:
9144 double weight = 1.0; //If normalized to the SM
9145 double muProd = myNPbase->STXS12_qqHqq_mjj60_120_Nj2(sqrt_s);
9146 double muProd1 = muProd -1.0;
9147 double muProd2 = 0.0;
9148
9149 //-- Decay:
9150 double BrHXXRatio = 1.0;
9151 double dBrHXXRatio1 = 0.0;
9152 double dBrHXXRatio2 = 0.0;
9153 if (fstate==0){
9154 // Use for Cross-section [pb] with no Higgs-boson decay
9155 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9156 } else if (fstate == 1){
9157 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9158 dBrHXXRatio1 = BrHXXRatio - 1.0;
9159 dBrHXXRatio2 = 0.0;
9160 } else if (fstate == 2){
9161 BrHXXRatio = (myNPbase->BrHgagaRatio());
9162 dBrHXXRatio1 = BrHXXRatio - 1.0;
9163 dBrHXXRatio2 = 0.0;
9164 } else if (fstate == 3){
9165 BrHXXRatio = (myNPbase->BrHbbRatio());
9166 dBrHXXRatio1 = BrHXXRatio - 1.0;
9167 dBrHXXRatio2 = 0.0;
9168 } else if (fstate == 4){
9169 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9170 dBrHXXRatio1 = BrHXXRatio - 1.0;
9171 dBrHXXRatio2 = 0.0;
9172 } else if (fstate == 5){
9173 BrHXXRatio = (myNPbase->BrHtautauRatio());
9174 dBrHXXRatio1 = BrHXXRatio - 1.0;
9175 dBrHXXRatio2 = 0.0;
9176 } else if (fstate == 6){
9177 BrHXXRatio = (myNPbase->BrHWWRatio());
9178 dBrHXXRatio1 = BrHXXRatio - 1.0;
9179 dBrHXXRatio2 = 0.0;
9180 } else if (fstate == 7){
9181 BrHXXRatio = (myNPbase->BrHZZRatio());
9182 dBrHXXRatio1 = BrHXXRatio - 1.0;
9183 dBrHXXRatio2 = 0.0;
9184 } else {
9185 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9186 }
9187
9188 //-- Production x Decay:
9189 if ((this->getModel()).isModelLinearized()){
9190 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9191 } else if((this->getModel()).isModelNPquadratic()){
9192 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9193 } else {
9194 return weight*(muProd)*(BrHXXRatio);
9195 }
9196}
9197
9198// -----------------------------------------------------------------------------
9199
9200STXS12_qqHqq_mjj120_350_Nj2::STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9201: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9202{
9203 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9204 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9205
9206}
9207
9209{
9210 double BrHXXRatio = 1.0;
9211 if (fstate == 1){
9212 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9213 } else if (fstate == 2){
9214 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9215 } else if (fstate == 3){
9216 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9217 } else if (fstate == 4){
9218 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9219 } else {
9220 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9221 }
9222
9223 if ((this->getModel()).isModelLinearized()) {
9224 return ((myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9225 } else {
9226 return (myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s))*(BrHXXRatio);
9227 }
9228}
9229
9230// -----------------------------------------------------------------------------
9231
9232//AG:STXS2024
9234: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9235{
9236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9237 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9238
9239}
9240
9242{
9243 //-- Production:
9244 double weight = 1.0; //If normalized to the SM
9246 double muProd1 = muProd -1.0;
9247 double muProd2 = 0.0;
9248
9249 //-- Decay:
9250 double BrHXXRatio = 1.0;
9251 double dBrHXXRatio1 = 0.0;
9252 double dBrHXXRatio2 = 0.0;
9253 if (fstate==0){
9254 // Use for Cross-section [pb] with no Higgs-boson decay
9255 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9256 } else if (fstate == 1){
9257 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9258 dBrHXXRatio1 = BrHXXRatio - 1.0;
9259 dBrHXXRatio2 = 0.0;
9260 } else if (fstate == 2){
9261 BrHXXRatio = (myNPbase->BrHgagaRatio());
9262 dBrHXXRatio1 = BrHXXRatio - 1.0;
9263 dBrHXXRatio2 = 0.0;
9264 } else if (fstate == 3){
9265 BrHXXRatio = (myNPbase->BrHbbRatio());
9266 dBrHXXRatio1 = BrHXXRatio - 1.0;
9267 dBrHXXRatio2 = 0.0;
9268 } else if (fstate == 4){
9269 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9270 dBrHXXRatio1 = BrHXXRatio - 1.0;
9271 dBrHXXRatio2 = 0.0;
9272 } else if (fstate == 5){
9273 BrHXXRatio = (myNPbase->BrHtautauRatio());
9274 dBrHXXRatio1 = BrHXXRatio - 1.0;
9275 dBrHXXRatio2 = 0.0;
9276 } else if (fstate == 6){
9277 BrHXXRatio = (myNPbase->BrHWWRatio());
9278 dBrHXXRatio1 = BrHXXRatio - 1.0;
9279 dBrHXXRatio2 = 0.0;
9280 } else if (fstate == 7){
9281 BrHXXRatio = (myNPbase->BrHZZRatio());
9282 dBrHXXRatio1 = BrHXXRatio - 1.0;
9283 dBrHXXRatio2 = 0.0;
9284 } else {
9285 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9286 }
9287
9288
9289 //-- Production x Decay:
9290 if ((this->getModel()).isModelLinearized()){
9291 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9292 } else if((this->getModel()).isModelNPquadratic()){
9293 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9294 } else {
9295 return weight*(muProd)*(BrHXXRatio);
9296 }
9297
9298}
9299
9300// -----------------------------------------------------------------------------
9301
9303: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9304{
9305 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9306 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9307
9308}
9309
9311{
9312 double BrHXXRatio = 1.0;
9313 if (fstate == 1){
9314 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9315 } else if (fstate == 2){
9316 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9317 } else if (fstate == 3){
9318 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9319 } else if (fstate == 4){
9320 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9321 } else {
9322 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9323 }
9324
9325 if ((this->getModel()).isModelLinearized()) {
9326 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9327 } else {
9329 }
9330}
9331
9332// -----------------------------------------------------------------------------
9333
9335: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9336{
9337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9338 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9339
9340}
9341
9343{
9344 double BrHXXRatio = 1.0;
9345 if (fstate == 1){
9346 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9347 } else if (fstate == 2){
9348 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9349 } else if (fstate == 3){
9350 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9351 } else if (fstate == 4){
9352 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9353 } else {
9354 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9355 }
9356
9357 if ((this->getModel()).isModelLinearized()) {
9358 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9359 } else {
9361 }
9362}
9363
9364// -----------------------------------------------------------------------------
9365
9367: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9368{
9369 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9370 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9371
9372}
9373
9375{
9376 double BrHXXRatio = 1.0;
9377 if (fstate == 1){
9378 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9379 } else if (fstate == 2){
9380 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9381 } else if (fstate == 3){
9382 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9383 } else if (fstate == 4){
9384 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9385 } else {
9386 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9387 }
9388
9389 if ((this->getModel()).isModelLinearized()) {
9390 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9391 } else {
9393 }
9394}
9395
9396// -----------------------------------------------------------------------------
9397
9399: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9400{
9401 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9402 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9403
9404}
9405
9407{
9408 double BrHXXRatio = 1.0;
9409 if (fstate == 1){
9410 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9411 } else if (fstate == 2){
9412 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9413 } else if (fstate == 3){
9414 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9415 } else if (fstate == 4){
9416 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9417 } else {
9418 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9419 }
9420
9421 if ((this->getModel()).isModelLinearized()) {
9422 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9423 } else {
9425 }
9426}
9427
9428// -----------------------------------------------------------------------------
9429
9430//AG:STXS2024
9431STXS12_qqHqq_mjj350_700_pTH0_200_Nj2::STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9432: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9433{
9434 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9435 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9436
9437}
9438
9440{
9441 //-- Production:
9442 double weight = 1.0; //If normalized to the SM
9444 double muProd1 = muProd -1.0;
9445 double muProd2 = 0.0;
9446
9447 //-- Decay:
9448 double BrHXXRatio = 1.0;
9449 double dBrHXXRatio1 = 0.0;
9450 double dBrHXXRatio2 = 0.0;
9451 if (fstate==0){
9452 // Use for Cross-section [pb] with no Higgs-boson decay
9453 weight = 0.53537; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9454 } else if (fstate == 1){
9455 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9456 dBrHXXRatio1 = BrHXXRatio - 1.0;
9457 dBrHXXRatio2 = 0.0;
9458 } else if (fstate == 2){
9459 BrHXXRatio = (myNPbase->BrHgagaRatio());
9460 dBrHXXRatio1 = BrHXXRatio - 1.0;
9461 dBrHXXRatio2 = 0.0;
9462 } else if (fstate == 3){
9463 BrHXXRatio = (myNPbase->BrHbbRatio());
9464 dBrHXXRatio1 = BrHXXRatio - 1.0;
9465 dBrHXXRatio2 = 0.0;
9466 } else if (fstate == 4){
9467 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9468 dBrHXXRatio1 = BrHXXRatio - 1.0;
9469 dBrHXXRatio2 = 0.0;
9470 } else if (fstate == 5){
9471 BrHXXRatio = (myNPbase->BrHtautauRatio());
9472 dBrHXXRatio1 = BrHXXRatio - 1.0;
9473 dBrHXXRatio2 = 0.0;
9474 } else if (fstate == 6){
9475 BrHXXRatio = (myNPbase->BrHWWRatio());
9476 dBrHXXRatio1 = BrHXXRatio - 1.0;
9477 dBrHXXRatio2 = 0.0;
9478 } else {
9479 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9480 }
9481
9482 //-- Production x Decay:
9483 if ((this->getModel()).isModelLinearized()){
9484 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9485 } else if((this->getModel()).isModelNPquadratic()){
9486 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9487 } else {
9488 return weight*(muProd)*(BrHXXRatio);
9489 }
9490
9491
9492}
9493
9494// -----------------------------------------------------------------------------
9495
9496//AG:STXS2024
9497STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2::STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9498: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9499{
9500 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9501 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9502
9503}
9504
9506{
9507 //-- Production:
9508 double weight = 1.0; //If normalized to the SM
9510 double muProd1 = muProd -1.0;
9511 double muProd2 = 0.0;
9512
9513 //-- Decay:
9514 double BrHXXRatio = 1.0;
9515 double dBrHXXRatio1 = 0.0;
9516 double dBrHXXRatio2 = 0.0;
9517 if (fstate==0){
9518 // Use for Cross-section [pb] with no Higgs-boson decay
9519 weight = 0.25614; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9520 } else if (fstate == 1){
9521 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9522 dBrHXXRatio1 = BrHXXRatio - 1.0;
9523 dBrHXXRatio2 = 0.0;
9524 } else if (fstate == 2){
9525 BrHXXRatio = (myNPbase->BrHgagaRatio());
9526 dBrHXXRatio1 = BrHXXRatio - 1.0;
9527 dBrHXXRatio2 = 0.0;
9528 } else if (fstate == 3){
9529 BrHXXRatio = (myNPbase->BrHbbRatio());
9530 dBrHXXRatio1 = BrHXXRatio - 1.0;
9531 dBrHXXRatio2 = 0.0;
9532 } else if (fstate == 4){
9533 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9534 dBrHXXRatio1 = BrHXXRatio - 1.0;
9535 dBrHXXRatio2 = 0.0;
9536 } else if (fstate == 5){
9537 BrHXXRatio = (myNPbase->BrHtautauRatio());
9538 dBrHXXRatio1 = BrHXXRatio - 1.0;
9539 dBrHXXRatio2 = 0.0;
9540 } else if (fstate == 6){
9541 BrHXXRatio = (myNPbase->BrHWWRatio());
9542 dBrHXXRatio1 = BrHXXRatio - 1.0;
9543 dBrHXXRatio2 = 0.0;
9544 } else {
9545 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9546 }
9547
9548 //-- Production x Decay:
9549 if ((this->getModel()).isModelLinearized()){
9550 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9551 } else if((this->getModel()).isModelNPquadratic()){
9552 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9553 } else {
9554 return weight*(muProd)*(BrHXXRatio);
9555 }
9556
9557
9558}
9559
9560// -----------------------------------------------------------------------------
9561
9562//AG:STXS2024
9563STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9564: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9565{
9566 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9567 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9568
9569}
9570
9572{
9573 //-- Production:
9574 double weight = 1.0; //If normalized to the SM
9576 double muProd1 = muProd -1.0;
9577 double muProd2 = 0.0;
9578
9579 //-- Decay:
9580 double BrHXXRatio = 1.0;
9581 double dBrHXXRatio1 = 0.0;
9582 double dBrHXXRatio2 = 0.0;
9583 if (fstate==0){
9584 // Use for Cross-section [pb] with no Higgs-boson decay
9585 weight = 0.22408; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9586 } else if (fstate == 1){
9587 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9588 dBrHXXRatio1 = BrHXXRatio - 1.0;
9589 dBrHXXRatio2 = 0.0;
9590 } else if (fstate == 2){
9591 BrHXXRatio = (myNPbase->BrHgagaRatio());
9592 dBrHXXRatio1 = BrHXXRatio - 1.0;
9593 dBrHXXRatio2 = 0.0;
9594 } else if (fstate == 3){
9595 BrHXXRatio = (myNPbase->BrHbbRatio());
9596 dBrHXXRatio1 = BrHXXRatio - 1.0;
9597 dBrHXXRatio2 = 0.0;
9598 } else if (fstate == 4){
9599 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9600 dBrHXXRatio1 = BrHXXRatio - 1.0;
9601 dBrHXXRatio2 = 0.0;
9602 } else if (fstate == 5){
9603 BrHXXRatio = (myNPbase->BrHtautauRatio());
9604 dBrHXXRatio1 = BrHXXRatio - 1.0;
9605 dBrHXXRatio2 = 0.0;
9606 } else if (fstate == 6){
9607 BrHXXRatio = (myNPbase->BrHWWRatio());
9608 dBrHXXRatio1 = BrHXXRatio - 1.0;
9609 dBrHXXRatio2 = 0.0;
9610 } else {
9611 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9612 }
9613
9614 //-- Production x Decay:
9615 if ((this->getModel()).isModelLinearized()){
9616 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9617 } else if((this->getModel()).isModelNPquadratic()){
9618 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9619 } else {
9620 return weight*(muProd)*(BrHXXRatio);
9621 }
9622
9623
9624}
9625
9626// -----------------------------------------------------------------------------
9627
9628//AG:STXS2024
9629STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9630: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9631{
9632 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9633 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9634
9635}
9636
9638{
9639 //-- Production:
9640 double weight = 1.0; //If normalized to the SM
9642 double muProd1 = muProd -1.0;
9643 double muProd2 = 0.0;
9644
9645 //-- Decay:
9646 double BrHXXRatio = 1.0;
9647 double dBrHXXRatio1 = 0.0;
9648 double dBrHXXRatio2 = 0.0;
9649 if (fstate==0){
9650 // Use for Cross-section [pb] with no Higgs-boson decay
9651 weight = 0.21578; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9652 } else if (fstate == 1){
9653 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9654 dBrHXXRatio1 = BrHXXRatio - 1.0;
9655 dBrHXXRatio2 = 0.0;
9656 } else if (fstate == 2){
9657 BrHXXRatio = (myNPbase->BrHgagaRatio());
9658 dBrHXXRatio1 = BrHXXRatio - 1.0;
9659 dBrHXXRatio2 = 0.0;
9660 } else if (fstate == 3){
9661 BrHXXRatio = (myNPbase->BrHbbRatio());
9662 dBrHXXRatio1 = BrHXXRatio - 1.0;
9663 dBrHXXRatio2 = 0.0;
9664 } else if (fstate == 4){
9665 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9666 dBrHXXRatio1 = BrHXXRatio - 1.0;
9667 dBrHXXRatio2 = 0.0;
9668 } else if (fstate == 5){
9669 BrHXXRatio = (myNPbase->BrHtautauRatio());
9670 dBrHXXRatio1 = BrHXXRatio - 1.0;
9671 dBrHXXRatio2 = 0.0;
9672 } else if (fstate == 6){
9673 BrHXXRatio = (myNPbase->BrHWWRatio());
9674 dBrHXXRatio1 = BrHXXRatio - 1.0;
9675 dBrHXXRatio2 = 0.0;
9676 } else {
9677 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9678 }
9679
9680 //-- Production x Decay:
9681 if ((this->getModel()).isModelLinearized()){
9682 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9683 } else if((this->getModel()).isModelNPquadratic()){
9684 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9685 } else {
9686 return weight*(muProd)*(BrHXXRatio);
9687 }
9688
9689}
9690
9691// -----------------------------------------------------------------------------
9692
9693//AG:STXS2024
9694STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9695: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9696{
9697 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9698 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9699
9700}
9701
9703{
9704 //-- Production:
9705 double weight = 1.0; //If normalized to the SM
9706 //Since adding bins, include partial weigths of SM_predictions
9707 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9708 double muProd = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s))
9709 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)) / (0.30189+0.21578));
9710 double muProd1 = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s)-1.0)
9711 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)-1.0) / (0.30189+0.21578));
9712 double muProd2 = 0.0;
9713
9714 //-- Decay:
9715 double BrHXXRatio = 1.0;
9716 double dBrHXXRatio1 = 0.0;
9717 double dBrHXXRatio2 = 0.0;
9718 if (fstate==0){
9719 // Use for Cross-section [pb] with no Higgs-boson decay
9720 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9721 } else if (fstate == 1){
9722 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9723 dBrHXXRatio1 = BrHXXRatio - 1.0;
9724 dBrHXXRatio2 = 0.0;
9725 } else if (fstate == 2){
9726 BrHXXRatio = (myNPbase->BrHgagaRatio());
9727 dBrHXXRatio1 = BrHXXRatio - 1.0;
9728 dBrHXXRatio2 = 0.0;
9729 } else if (fstate == 3){
9730 BrHXXRatio = (myNPbase->BrHbbRatio());
9731 dBrHXXRatio1 = BrHXXRatio - 1.0;
9732 dBrHXXRatio2 = 0.0;
9733 } else if (fstate == 4){
9734 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9735 dBrHXXRatio1 = BrHXXRatio - 1.0;
9736 dBrHXXRatio2 = 0.0;
9737 } else {
9738 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9739 }
9740
9741 //-- Production x Decay:
9742 if ((this->getModel()).isModelLinearized()){
9743 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9744 } else if((this->getModel()).isModelNPquadratic()){
9745 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9746 } else {
9747 return weight*(muProd)*(BrHXXRatio);
9748 }
9749
9750
9751}
9752
9753// -----------------------------------------------------------------------------
9754
9755//AG:STXS2024
9756STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2::STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9757: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9758{
9759 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9760 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9761
9762}
9763
9765{
9766 //-- Production:
9767 double weight = 1.0; //If normalized to the SM
9769 double muProd1 = muProd -1.0;
9770 double muProd2 = 0.0;
9771
9772 //-- Decay:
9773 double BrHXXRatio = 1.0;
9774 double dBrHXXRatio1 = 0.0;
9775 double dBrHXXRatio2 = 0.0;
9776 if (fstate==0){
9777 // Use for Cross-section [pb] with no Higgs-boson decay
9778 weight = 0.07372 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9779 } else if (fstate == 1){
9780 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9781 dBrHXXRatio1 = BrHXXRatio - 1.0;
9782 dBrHXXRatio2 = 0.0;
9783 } else if (fstate == 2){
9784 BrHXXRatio = (myNPbase->BrHgagaRatio());
9785 dBrHXXRatio1 = BrHXXRatio - 1.0;
9786 dBrHXXRatio2 = 0.0;
9787 } else if (fstate == 3){
9788 BrHXXRatio = (myNPbase->BrHbbRatio());
9789 dBrHXXRatio1 = BrHXXRatio - 1.0;
9790 dBrHXXRatio2 = 0.0;
9791 } else if (fstate == 4){
9792 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9793 dBrHXXRatio1 = BrHXXRatio - 1.0;
9794 dBrHXXRatio2 = 0.0;
9795 } else {
9796 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9797 }
9798
9799 //-- Production x Decay:
9800 if ((this->getModel()).isModelLinearized()){
9801 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9802 } else if((this->getModel()).isModelNPquadratic()){
9803 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9804 } else {
9805 return weight*(muProd)*(BrHXXRatio);
9806 }
9807
9808
9809}
9810
9811// -----------------------------------------------------------------------------
9812
9813//AG:STXS2024
9814STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9815: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9816{
9817 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9818 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9819
9820}
9821
9823{
9824 //-- Production:
9825 double weight = 1.0; //If normalized to the SM
9827 double muProd1 = muProd -1.0;
9828 double muProd2 = 0.0;
9829
9830 //-- Decay:
9831 double BrHXXRatio = 1.0;
9832 double dBrHXXRatio1 = 0.0;
9833 double dBrHXXRatio2 = 0.0;
9834 if (fstate==0){
9835 // Use for Cross-section [pb] with no Higgs-boson decay
9836 weight = 0.07315 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9837 } else if (fstate == 1){
9838 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9839 dBrHXXRatio1 = BrHXXRatio - 1.0;
9840 dBrHXXRatio2 = 0.0;
9841 } else if (fstate == 2){
9842 BrHXXRatio = (myNPbase->BrHgagaRatio());
9843 dBrHXXRatio1 = BrHXXRatio - 1.0;
9844 dBrHXXRatio2 = 0.0;
9845 } else if (fstate == 3){
9846 BrHXXRatio = (myNPbase->BrHbbRatio());
9847 dBrHXXRatio1 = BrHXXRatio - 1.0;
9848 dBrHXXRatio2 = 0.0;
9849 } else if (fstate == 4){
9850 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9851 dBrHXXRatio1 = BrHXXRatio - 1.0;
9852 dBrHXXRatio2 = 0.0;
9853 } else {
9854 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9855 }
9856
9857 //-- Production x Decay:
9858 if ((this->getModel()).isModelLinearized()){
9859 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9860 } else if((this->getModel()).isModelNPquadratic()){
9861 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9862 } else {
9863 return weight*(muProd)*(BrHXXRatio);
9864 }
9865
9866
9867}
9868
9869// -----------------------------------------------------------------------------
9870
9871STXS12_qqHqq_mjj350_Inf_Nj2::STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9872: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9873{
9874 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9875 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
9876
9877}
9878
9880{
9881 //-- Production:
9882 double weight = 1.0; //If normalized to the SM
9883 //Since adding bins, include partial weigths of SM_predictions
9884 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9885
9886 double muProd = (0.53537*myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(sqrt_s)
9892 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
9893
9894 double muProd1 = muProd - 1.;
9895 double muProd2 = 0.0;
9896
9897 //-- Decay:
9898 double BrHXXRatio = 1.0;
9899 double dBrHXXRatio1 = 0.0;
9900 double dBrHXXRatio2 = 0.0;
9901 if (fstate==0){
9902 // Use for Cross-section [pb] with no Higgs-boson decay
9903 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9904 } else if (fstate == 1){
9905 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9906 dBrHXXRatio1 = BrHXXRatio - 1.0;
9907 dBrHXXRatio2 = 0.0;
9908 } else if (fstate == 2){
9909 BrHXXRatio = (myNPbase->BrHgagaRatio());
9910 dBrHXXRatio1 = BrHXXRatio - 1.0;
9911 dBrHXXRatio2 = 0.0;
9912 } else if (fstate == 3){
9913 BrHXXRatio = (myNPbase->BrHbbRatio());
9914 dBrHXXRatio1 = BrHXXRatio - 1.0;
9915 dBrHXXRatio2 = 0.0;
9916 } else if (fstate == 4){
9917 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9918 dBrHXXRatio1 = BrHXXRatio - 1.0;
9919 dBrHXXRatio2 = 0.0;
9920 } else if (fstate == 5){
9921 BrHXXRatio = (myNPbase->BrHtautauRatio());
9922 dBrHXXRatio1 = BrHXXRatio - 1.0;
9923 dBrHXXRatio2 = 0.0;
9924 } else {
9925 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9926 }
9927
9928
9929
9930
9931 //-- Production x Decay:
9932 if ((this->getModel()).isModelLinearized()){
9933// std::cout<<"\033[1;31m CHECK IF LINEAR \033[0m" << std::endl;
9934 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9935 } else if((this->getModel()).isModelNPquadratic()){
9936// std::cout<<"\033[1;31m CHECK IF QUADRATIC \033[0m" << std::endl;
9937 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9938 } else {
9939// std::cout<<"\033[1;31m CHECK IF NEITHER LINEAR NOR QUADRATIC \033[0m" << std::endl;
9940 return weight*(muProd)*(BrHXXRatio);
9941 }
9942
9943}
9944
9945// -----------------------------------------------------------------------------
9946
9947STXS12_qqHlv_pTV0_75::STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9948: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9949{
9950 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9951 throw std::runtime_error("STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
9952
9953}
9954
9956{
9957 //-- Production:
9958 double weight = 1.0; //If normalized to the SM
9959 double muProd = myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s);
9960 double muProd1 = muProd -1.0;
9961 double muProd2 = 0.0;
9962
9963 //-- Decay:
9964 double BrHXXRatio = 1.0;
9965 double dBrHXXRatio1 = 0.0;
9966 double dBrHXXRatio2 = 0.0;
9967 if (fstate==0){
9968 // Use for Cross-section [pb] with no Higgs-boson decay
9969 weight = 0.21509; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9970 } else if (fstate == 1){
9971 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9972 dBrHXXRatio1 = BrHXXRatio - 1.0;
9973 dBrHXXRatio2 = 0.0;
9974 } else if (fstate == 2){
9975 BrHXXRatio = (myNPbase->BrHgagaRatio());
9976 dBrHXXRatio1 = BrHXXRatio - 1.0;
9977 dBrHXXRatio2 = 0.0;
9978 } else if (fstate == 3){
9979 BrHXXRatio = (myNPbase->BrHbbRatio());
9980 dBrHXXRatio1 = BrHXXRatio - 1.0;
9981 dBrHXXRatio2 = 0.0;
9982 } else if (fstate == 4){
9983 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9984 dBrHXXRatio1 = BrHXXRatio - 1.0;
9985 dBrHXXRatio2 = 0.0;
9986 } else if (fstate == 5){
9987 BrHXXRatio = (myNPbase->BrHtautauRatio());
9988 dBrHXXRatio1 = BrHXXRatio - 1.0;
9989 dBrHXXRatio2 = 0.0;
9990 } else {
9991 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9992 }
9993
9994 //-- Production x Decay:
9995 if ((this->getModel()).isModelLinearized()){
9996 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9997 } else if((this->getModel()).isModelNPquadratic()){
9998 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9999 } else {
10000 return weight*(muProd)*(BrHXXRatio);
10001 }
10002
10003}
10004
10005// -----------------------------------------------------------------------------
10006
10007STXS12_qqHlv_pTV75_150::STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10008: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10009{
10010 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10011 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
10012
10013}
10014
10016{
10017 //-- Production:
10018 double weight = 1.0; //If normalized to the SM
10019 double muProd = myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s);
10020 double muProd1 = muProd -1.0;
10021 double muProd2 = 0.0;
10022
10023 //-- Decay:
10024 double BrHXXRatio = 1.0;
10025 double dBrHXXRatio1 = 0.0;
10026 double dBrHXXRatio2 = 0.0;
10027 if (fstate==0){
10028 // Use for Cross-section [pb] with no Higgs-boson decay
10029 weight = 0.13440; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10030 } else if (fstate == 1){
10031 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10032 dBrHXXRatio1 = BrHXXRatio - 1.0;
10033 dBrHXXRatio2 = 0.0;
10034 } else if (fstate == 2){
10035 BrHXXRatio = (myNPbase->BrHgagaRatio());
10036 dBrHXXRatio1 = BrHXXRatio - 1.0;
10037 dBrHXXRatio2 = 0.0;
10038 } else if (fstate == 3){
10039 BrHXXRatio = (myNPbase->BrHbbRatio());
10040 dBrHXXRatio1 = BrHXXRatio - 1.0;
10041 dBrHXXRatio2 = 0.0;
10042 } else if (fstate == 4){
10043 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10044 dBrHXXRatio1 = BrHXXRatio - 1.0;
10045 dBrHXXRatio2 = 0.0;
10046 } else if (fstate == 5){
10047 BrHXXRatio = (myNPbase->BrHtautauRatio());
10048 dBrHXXRatio1 = BrHXXRatio - 1.0;
10049 dBrHXXRatio2 = 0.0;
10050 } else {
10051 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
10052 }
10053
10054 //-- Production x Decay:
10055 if ((this->getModel()).isModelLinearized()){
10056 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10057 } else if((this->getModel()).isModelNPquadratic()){
10058 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10059 } else {
10060 return weight*(muProd)*(BrHXXRatio);
10061 }
10062
10063}
10064
10065// -----------------------------------------------------------------------------
10066
10067//AG:STXS2024
10068STXS12_qqHlv_pTV150_250_Nj0::STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10069: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10070{
10071 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10072 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10073
10074}
10075
10077{
10078 //-- Production:
10079 double weight = 1.0; //If normalized to the SM
10081 double muProd1 = myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) - 1.0;
10082 double muProd2 = 0.0;
10083
10084 //-- Decay:
10085 double BrHXXRatio = 1.0;
10086 double dBrHXXRatio1 = 0.0;
10087 double dBrHXXRatio2 = 0.0;
10088 if (fstate==0){
10089 // Use for Cross-section [pb] with no Higgs-boson decay
10090 weight = 0.04117; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10091 } else if (fstate == 1){
10092 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10093 dBrHXXRatio1 = BrHXXRatio - 1.0;
10094 dBrHXXRatio2 = 0.0;
10095 } else if (fstate == 2){
10096 BrHXXRatio = (myNPbase->BrHgagaRatio());
10097 dBrHXXRatio1 = BrHXXRatio - 1.0;
10098 dBrHXXRatio2 = 0.0;
10099 } else if (fstate == 3){
10100 BrHXXRatio = (myNPbase->BrHbbRatio());
10101 dBrHXXRatio1 = BrHXXRatio - 1.0;
10102 dBrHXXRatio2 = 0.0;
10103 } else if (fstate == 4){
10104 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10105 dBrHXXRatio1 = BrHXXRatio - 1.0;
10106 dBrHXXRatio2 = 0.0;
10107 } else if (fstate == 5){
10108 BrHXXRatio = (myNPbase->BrHtautauRatio());
10109 dBrHXXRatio1 = BrHXXRatio - 1.0;
10110 dBrHXXRatio2 = 0.0;
10111 } else {
10112 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10113 }
10114
10115 //-- Production x Decay:
10116 if ((this->getModel()).isModelLinearized()){
10117 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10118 } else if((this->getModel()).isModelNPquadratic()){
10119 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10120 } else {
10121 return weight*(muProd)*(BrHXXRatio);
10122 }
10123
10124
10125}
10126
10127// -----------------------------------------------------------------------------
10128
10129STXS12_qqHlv_pTV150_250_Nj1::STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10130: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10131{
10132 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10133 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10134
10135}
10136
10138{
10139 double BrHXXRatio = 1.0;
10140 if (fstate == 1){
10141 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10142 } else if (fstate == 2){
10143 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10144 } else if (fstate == 3){
10145 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10146 } else if (fstate == 4){
10147 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10148 } else {
10149 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10150 }
10151
10152 if ((this->getModel()).isModelLinearized()) {
10153 return ((myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10154 } else {
10155 return (myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10156 }
10157}
10158
10159// -----------------------------------------------------------------------------
10160
10161STXS12_qqHlv_pTV250_Inf::STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10162: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10163{
10164 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10165 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10166
10167}
10168
10170{
10171 double BrHXXRatio = 1.0;
10172 if (fstate == 1){
10173 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10174 } else if (fstate == 2){
10175 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10176 } else if (fstate == 3){
10177 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10178 } else if (fstate == 4){
10179 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10180 } else {
10181 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10182 }
10183
10184 if ((this->getModel()).isModelLinearized()) {
10185 return ((myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10186 } else {
10187 return (myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10188 }
10189}
10190
10191// -----------------------------------------------------------------------------
10192
10193//AG:STXS2024
10194STXS12_qqHlv_pTV0_150::STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10195: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10196{
10197 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10198 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10199
10200}
10201
10203{
10204 //-- Production:
10205 double weight = 1.0; //If normalized to the SM
10206 //Since adding bins, include partial weigths of SM_predictions
10207 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10208 double muProd = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s))
10209 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s))/(0.21509+0.13440));
10210 double muProd1 = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10211 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)/(0.21509+0.13440));
10212 double muProd2 = 0.0;
10213
10214 //-- Decay:
10215 double BrHXXRatio = 1.0;
10216 double dBrHXXRatio1 = 0.0;
10217 double dBrHXXRatio2 = 0.0;
10218 if (fstate==0){
10219 // Use for Cross-section [pb] with no Higgs-boson decay
10220 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10221 } else if (fstate == 1){
10222 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10223 dBrHXXRatio1 = BrHXXRatio - 1.0;
10224 dBrHXXRatio2 = 0.0;
10225 } else if (fstate == 2){
10226 BrHXXRatio = (myNPbase->BrHgagaRatio());
10227 dBrHXXRatio1 = BrHXXRatio - 1.0;
10228 dBrHXXRatio2 = 0.0;
10229 } else if (fstate == 3){
10230 BrHXXRatio = (myNPbase->BrHbbRatio());
10231 dBrHXXRatio1 = BrHXXRatio - 1.0;
10232 dBrHXXRatio2 = 0.0;
10233 } else if (fstate == 4){
10234 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10235 dBrHXXRatio1 = BrHXXRatio - 1.0;
10236 dBrHXXRatio2 = 0.0;
10237 } else {
10238 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10239 }
10240
10241 //-- Production x Decay:
10242 if ((this->getModel()).isModelLinearized()){
10243 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10244 } else if((this->getModel()).isModelNPquadratic()){
10245 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10246 } else {
10247 return weight*(muProd)*(BrHXXRatio);
10248 }
10249
10250
10251}
10252
10253// -----------------------------------------------------------------------------
10254
10255//AG:STXS2024
10256STXS12_qqHlv_pTV150_Inf::STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10257: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10258{
10259 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10260 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
10261
10262}
10263
10265{
10266 //-- Production:
10267 double weight = 1.0; //If normalized to the SM
10268 //Since adding bins, include partial weigths of SM_predictions
10269 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10270 double muProd = (0.04117 * myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
10272 + 0.00214 * myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) )/(0.04117+0.01004+0.00214);
10273 double muProd1 = (0.04117 * (myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) -1.0)
10274 + 0.01004 * (myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10275 + 0.00214 * (myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0) )/(0.04117+0.01004+0.00214);
10276 double muProd2 = 0.0;
10277
10278 //-- Decay:
10279 double BrHXXRatio = 1.0;
10280 double dBrHXXRatio1 = 0.0;
10281 double dBrHXXRatio2 = 0.0;
10282 if (fstate==0){
10283 // Use for Cross-section [pb] with no Higgs-boson decay
10284 weight = 1.0 ;
10285 } else if (fstate == 1){
10286 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10287 dBrHXXRatio1 = BrHXXRatio - 1.0;
10288 dBrHXXRatio2 = 0.0;
10289 } else if (fstate == 2){
10290 BrHXXRatio = (myNPbase->BrHgagaRatio());
10291 dBrHXXRatio1 = BrHXXRatio - 1.0;
10292 dBrHXXRatio2 = 0.0;
10293 } else if (fstate == 3){
10294 BrHXXRatio = (myNPbase->BrHbbRatio());
10295 dBrHXXRatio1 = BrHXXRatio - 1.0;
10296 dBrHXXRatio2 = 0.0;
10297 } else if (fstate == 4){
10298 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10299 dBrHXXRatio1 = BrHXXRatio - 1.0;
10300 dBrHXXRatio2 = 0.0;
10301 } else {
10302 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
10303 }
10304
10305 //-- Production x Decay:
10306 if ((this->getModel()).isModelLinearized()){
10307 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10308 } else if((this->getModel()).isModelNPquadratic()){
10309 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10310 } else {
10311 return weight*(muProd)*(BrHXXRatio);
10312 }
10313
10314
10315}
10316
10317// -----------------------------------------------------------------------------
10318
10319//AG:STXS2024
10320STXS12_qqHlv_pTV250_400::STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10321: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10322{
10323 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10324 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
10325
10326}
10327
10329{
10330 //-- Production:
10331 double weight = 1.0; //If normalized to the SM
10332 double muProd = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s) ;
10333 double muProd1 = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0 ;
10334 double muProd2 = 0.0;
10335
10336 //-- Decay:
10337 double BrHXXRatio = 1.0;
10338 double dBrHXXRatio1 = 0.0;
10339 double dBrHXXRatio2 = 0.0;
10340 if (fstate==0){
10341 // Use for Cross-section [pb] with no Higgs-boson decay
10342 weight =0.01004 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10343 } else if (fstate == 1){
10344 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10345 dBrHXXRatio1 = BrHXXRatio - 1.0;
10346 dBrHXXRatio2 = 0.0;
10347 } else if (fstate == 2){
10348 BrHXXRatio = (myNPbase->BrHgagaRatio());
10349 dBrHXXRatio1 = BrHXXRatio - 1.0;
10350 dBrHXXRatio2 = 0.0;
10351 } else if (fstate == 3){
10352 BrHXXRatio = (myNPbase->BrHbbRatio());
10353 dBrHXXRatio1 = BrHXXRatio - 1.0;
10354 dBrHXXRatio2 = 0.0;
10355 } else if (fstate == 4){
10356 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10357 dBrHXXRatio1 = BrHXXRatio - 1.0;
10358 dBrHXXRatio2 = 0.0;
10359 } else {
10360 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
10361 }
10362
10363 //-- Production x Decay:
10364 if ((this->getModel()).isModelLinearized()){
10365 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10366 } else if((this->getModel()).isModelNPquadratic()){
10367 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10368 } else {
10369 return weight*(muProd)*(BrHXXRatio);
10370 }
10371
10372
10373}
10374
10375// -----------------------------------------------------------------------------
10376
10377//AG:STXS2024
10378STXS12_qqHlv_pTV400_Inf::STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10379: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10380{
10381 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10382 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
10383
10384}
10385
10387{
10388 //-- Production:
10389 double weight = 1.0; //If normalized to the SM
10390 double muProd = myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) ;
10391 double muProd1 = muProd-1.0 ;
10392 double muProd2 = 0.0;
10393
10394 //-- Decay:
10395 double BrHXXRatio = 1.0;
10396 double dBrHXXRatio1 = 0.0;
10397 double dBrHXXRatio2 = 0.0;
10398 if (fstate==0){
10399 // Use for Cross-section [pb] with no Higgs-boson decay
10400 weight =0.00214 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10401 } else if (fstate == 1){
10402 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10403 dBrHXXRatio1 = BrHXXRatio - 1.0;
10404 dBrHXXRatio2 = 0.0;
10405 } else if (fstate == 2){
10406 BrHXXRatio = (myNPbase->BrHgagaRatio());
10407 dBrHXXRatio1 = BrHXXRatio - 1.0;
10408 dBrHXXRatio2 = 0.0;
10409 } else if (fstate == 3){
10410 BrHXXRatio = (myNPbase->BrHbbRatio());
10411 dBrHXXRatio1 = BrHXXRatio - 1.0;
10412 dBrHXXRatio2 = 0.0;
10413 } else if (fstate == 4){
10414 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10415 dBrHXXRatio1 = BrHXXRatio - 1.0;
10416 dBrHXXRatio2 = 0.0;
10417 } else {
10418 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
10419 }
10420
10421 //-- Production x Decay:
10422 if ((this->getModel()).isModelLinearized()){
10423 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10424 } else if((this->getModel()).isModelNPquadratic()){
10425 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10426 } else {
10427 return weight*(muProd)*(BrHXXRatio);
10428 }
10429
10430
10431}
10432
10433
10434// -----------------------------------------------------------------------------
10435
10436STXS12_qqHll_pTV0_75::STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10437: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10438{
10439 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10440 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
10441
10442}
10443
10445{
10446 double BrHXXRatio = 1.0;
10447 if (fstate == 1){
10448 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10449 } else if (fstate == 2){
10450 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10451 } else if (fstate == 3){
10452 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10453 } else if (fstate == 4){
10454 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10455 } else {
10456 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
10457 }
10458
10459 if ((this->getModel()).isModelLinearized()) {
10460 return ((myNPbase->STXS12_qqHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
10461 } else {
10462 return (myNPbase->STXS12_qqHll_pTV0_75(sqrt_s))*(BrHXXRatio);
10463 }
10464}
10465
10466// -----------------------------------------------------------------------------
10467
10468//AG:STXS2024
10469STXS12_qqHll_pTV75_150::STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10470: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10471{
10472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10473 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
10474
10475}
10476
10478{
10479 //-- Production:
10480 double weight = 1.0; //If normalized to the SM
10481 double muProd = myNPbase->STXS12_qqHll_pTV75_150(sqrt_s);
10482 double muProd1 = muProd -1.0;
10483 double muProd2 = 0.0;
10484
10485 //-- Decay:
10486 double BrHXXRatio = 1.0;
10487 double dBrHXXRatio1 = 0.0;
10488 double dBrHXXRatio2 = 0.0;
10489 if (fstate==0){
10490 // Use for Cross-section [pb] with no Higgs-boson decay
10491 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10492 } else if (fstate == 1){
10493 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10494 dBrHXXRatio1 = BrHXXRatio - 1.0;
10495 dBrHXXRatio2 = 0.0;
10496 } else if (fstate == 2){
10497 BrHXXRatio = (myNPbase->BrHgagaRatio());
10498 dBrHXXRatio1 = BrHXXRatio - 1.0;
10499 dBrHXXRatio2 = 0.0;
10500 } else if (fstate == 3){
10501 BrHXXRatio = (myNPbase->BrHbbRatio());
10502 dBrHXXRatio1 = BrHXXRatio - 1.0;
10503 dBrHXXRatio2 = 0.0;
10504 } else if (fstate == 4){
10505 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10506 dBrHXXRatio1 = BrHXXRatio - 1.0;
10507 dBrHXXRatio2 = 0.0;
10508 } else {
10509 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
10510 }
10511
10512 //-- Production x Decay:
10513 if ((this->getModel()).isModelLinearized()){
10514 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10515 } else if((this->getModel()).isModelNPquadratic()){
10516 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10517 } else {
10518 return weight*(muProd)*(BrHXXRatio);
10519 }
10520
10521
10522}
10523
10524// -----------------------------------------------------------------------------
10525
10526//AG:STXS2024
10527STXS12_qqHll_pTV150_250_Nj0::STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10528: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10529{
10530 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10531 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10532
10533}
10534
10536{
10537 //-- Production:
10538 double weight = 1.0; //If normalized to the SM
10540 double muProd1 = muProd -1.0;
10541 double muProd2 = 0.0;
10542
10543 //-- Decay:
10544 double BrHXXRatio = 1.0;
10545 double dBrHXXRatio1 = 0.0;
10546 double dBrHXXRatio2 = 0.0;
10547 if (fstate==0){
10548 // Use for Cross-section [pb] with no Higgs-boson decay
10549 weight = 0.03223 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10550 } else if (fstate == 1){
10551 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10552 dBrHXXRatio1 = BrHXXRatio - 1.0;
10553 dBrHXXRatio2 = 0.0;
10554 } else if (fstate == 2){
10555 BrHXXRatio = (myNPbase->BrHgagaRatio());
10556 dBrHXXRatio1 = BrHXXRatio - 1.0;
10557 dBrHXXRatio2 = 0.0;
10558 } else if (fstate == 3){
10559 BrHXXRatio = (myNPbase->BrHbbRatio());
10560 dBrHXXRatio1 = BrHXXRatio - 1.0;
10561 dBrHXXRatio2 = 0.0;
10562 } else if (fstate == 4){
10563 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10564 dBrHXXRatio1 = BrHXXRatio - 1.0;
10565 dBrHXXRatio2 = 0.0;
10566 } else {
10567 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
10568 }
10569
10570 //-- Production x Decay:
10571 if ((this->getModel()).isModelLinearized()){
10572 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10573 } else if((this->getModel()).isModelNPquadratic()){
10574 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10575 } else {
10576 return weight*(muProd)*(BrHXXRatio);
10577 }
10578
10579}
10580
10581// -----------------------------------------------------------------------------
10582
10583STXS12_qqHll_pTV150_250_Nj1::STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10584: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10585{
10586 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10587 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10588
10589}
10590
10592{
10593 double BrHXXRatio = 1.0;
10594 if (fstate == 1){
10595 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10596 } else if (fstate == 2){
10597 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10598 } else if (fstate == 3){
10599 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10600 } else if (fstate == 4){
10601 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10602 } else {
10603 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10604 }
10605
10606 if ((this->getModel()).isModelLinearized()) {
10607 return ((myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10608 } else {
10609 return (myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10610 }
10611}
10612
10613// -----------------------------------------------------------------------------
10614
10615STXS12_qqHll_pTV250_Inf::STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10616: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10617{
10618 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10619 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
10620
10621}
10622
10624{
10625 double BrHXXRatio = 1.0;
10626 if (fstate == 1){
10627 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10628 } else if (fstate == 2){
10629 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10630 } else if (fstate == 3){
10631 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10632 } else if (fstate == 4){
10633 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10634 } else {
10635 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
10636 }
10637
10638 if ((this->getModel()).isModelLinearized()) {
10639 return ((myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10640 } else {
10641 return (myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10642 }
10643}
10644
10645
10646// -----------------------------------------------------------------------------
10647
10648//AG:STXS2024
10649STXS12_qqHll_pTV0_150::STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10650: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10651{
10652 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10653 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
10654
10655}
10656
10658{
10659 //-- Production:
10660 double weight = 1.0; //If normalized to the SM
10661 double muProd = myNPbase->STXS12_qqHll_pTV0_150(sqrt_s);
10662 double muProd1 = muProd -1.0;
10663 double muProd2 = 0.0;
10664
10665 //-- Decay:
10666 double BrHXXRatio = 1.0;
10667 double dBrHXXRatio1 = 0.0;
10668 double dBrHXXRatio2 = 0.0;
10669 if (fstate==0){
10670 // Use for Cross-section [pb] with no Higgs-boson decay
10671 weight = 0.19845 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10672 } else if (fstate == 1){
10673 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10674 dBrHXXRatio1 = BrHXXRatio - 1.0;
10675 dBrHXXRatio2 = 0.0;
10676 } else if (fstate == 2){
10677 BrHXXRatio = (myNPbase->BrHgagaRatio());
10678 dBrHXXRatio1 = BrHXXRatio - 1.0;
10679 dBrHXXRatio2 = 0.0;
10680 } else if (fstate == 3){
10681 BrHXXRatio = (myNPbase->BrHbbRatio());
10682 dBrHXXRatio1 = BrHXXRatio - 1.0;
10683 dBrHXXRatio2 = 0.0;
10684 } else if (fstate == 4){
10685 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10686 dBrHXXRatio1 = BrHXXRatio - 1.0;
10687 dBrHXXRatio2 = 0.0;
10688 } else {
10689 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
10690 }
10691
10692 //-- Production x Decay:
10693 if ((this->getModel()).isModelLinearized()){
10694 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10695 } else if((this->getModel()).isModelNPquadratic()){
10696 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10697 } else {
10698 return weight*(muProd)*(BrHXXRatio);
10699 }
10700
10701}
10702
10703// -----------------------------------------------------------------------------
10704
10705//AG:STXS2024
10706STXS12_qqHll_pTV250_400::STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10707: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10708{
10709 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10710 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
10711
10712}
10713
10715{
10716 //-- Production:
10717 double weight = 1.0; //If normalized to the SM
10718 double muProd = myNPbase->STXS12_qqHll_pTV250_400(sqrt_s);
10719 double muProd1 = muProd -1.0;
10720 double muProd2 = 0.0;
10721
10722 //-- Decay:
10723 double BrHXXRatio = 1.0;
10724 double dBrHXXRatio1 = 0.0;
10725 double dBrHXXRatio2 = 0.0;
10726 if (fstate==0){
10727 // Use for Cross-section [pb] with no Higgs-boson decay
10728 weight = 0.00715 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10729 } else if (fstate == 1){
10730 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10731 dBrHXXRatio1 = BrHXXRatio - 1.0;
10732 dBrHXXRatio2 = 0.0;
10733 } else if (fstate == 2){
10734 BrHXXRatio = (myNPbase->BrHgagaRatio());
10735 dBrHXXRatio1 = BrHXXRatio - 1.0;
10736 dBrHXXRatio2 = 0.0;
10737 } else if (fstate == 3){
10738 BrHXXRatio = (myNPbase->BrHbbRatio());
10739 dBrHXXRatio1 = BrHXXRatio - 1.0;
10740 dBrHXXRatio2 = 0.0;
10741 } else if (fstate == 4){
10742 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10743 dBrHXXRatio1 = BrHXXRatio - 1.0;
10744 dBrHXXRatio2 = 0.0;
10745 } else {
10746 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
10747 }
10748
10749 //-- Production x Decay:
10750 if ((this->getModel()).isModelLinearized()){
10751 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10752 } else if((this->getModel()).isModelNPquadratic()){
10753 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10754 } else {
10755 return weight*(muProd)*(BrHXXRatio);
10756 }
10757
10758}
10759
10760// -----------------------------------------------------------------------------
10761
10762//AG:STXS2024
10763STXS12_qqHll_pTV400_Inf::STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10764: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10765{
10766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10767 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
10768
10769}
10770
10772{
10773 //-- Production:
10774 double weight = 1.0; //If normalized to the SM
10775 double muProd = myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s);
10776 double muProd1 = muProd -1.0;
10777 double muProd2 = 0.0;
10778
10779 //-- Decay:
10780 double BrHXXRatio = 1.0;
10781 double dBrHXXRatio1 = 0.0;
10782 double dBrHXXRatio2 = 0.0;
10783 if (fstate==0){
10784 // Use for Cross-section [pb] with no Higgs-boson decay
10785 weight = 0.00126 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10786 } else if (fstate == 1){
10787 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10788 dBrHXXRatio1 = BrHXXRatio - 1.0;
10789 dBrHXXRatio2 = 0.0;
10790 } else if (fstate == 2){
10791 BrHXXRatio = (myNPbase->BrHgagaRatio());
10792 dBrHXXRatio1 = BrHXXRatio - 1.0;
10793 dBrHXXRatio2 = 0.0;
10794 } else if (fstate == 3){
10795 BrHXXRatio = (myNPbase->BrHbbRatio());
10796 dBrHXXRatio1 = BrHXXRatio - 1.0;
10797 dBrHXXRatio2 = 0.0;
10798 } else if (fstate == 4){
10799 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10800 dBrHXXRatio1 = BrHXXRatio - 1.0;
10801 dBrHXXRatio2 = 0.0;
10802 } else {
10803 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
10804 }
10805
10806 //-- Production x Decay:
10807 if ((this->getModel()).isModelLinearized()){
10808 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10809 } else if((this->getModel()).isModelNPquadratic()){
10810 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10811 } else {
10812 return weight*(muProd)*(BrHXXRatio);
10813 }
10814
10815
10816}
10817
10818// -----------------------------------------------------------------------------
10819
10820//AG:STXS2024
10821STXS12_qqHll_pTV150_Inf::STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10822: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10823{
10824 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10825 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
10826
10827}
10828
10830{
10831 //-- Production:
10832 double weight = 1.0; //If normalized to the SM
10833 //Since adding bins, include partial weigths of SM_predictions
10834 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10835 double muProd = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s))
10837 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)) )/(0.03223+0.00715+0.00126);
10838 double muProd1 = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s)-1.0)
10839 + 0.00715*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10840 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )/(0.03223+0.00715+0.00126);
10841 double muProd2 = 0.0;
10842
10843 //-- Decay:
10844 double BrHXXRatio = 1.0;
10845 double dBrHXXRatio1 = 0.0;
10846 double dBrHXXRatio2 = 0.0;
10847 if (fstate==0){
10848 weight = 1.0 ;
10849 } else if (fstate == 1){
10850 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10851 dBrHXXRatio1 = BrHXXRatio - 1.0;
10852 dBrHXXRatio2 = 0.0;
10853 } else if (fstate == 2){
10854 BrHXXRatio = (myNPbase->BrHgagaRatio());
10855 dBrHXXRatio1 = BrHXXRatio - 1.0;
10856 dBrHXXRatio2 = 0.0;
10857 } else if (fstate == 3){
10858 BrHXXRatio = (myNPbase->BrHbbRatio());
10859 dBrHXXRatio1 = BrHXXRatio - 1.0;
10860 dBrHXXRatio2 = 0.0;
10861 } else if (fstate == 4){
10862 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10863 dBrHXXRatio1 = BrHXXRatio - 1.0;
10864 dBrHXXRatio2 = 0.0;
10865 } else {
10866 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
10867 }
10868
10869 //-- Production x Decay:
10870 if ((this->getModel()).isModelLinearized()){
10871 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10872 } else if((this->getModel()).isModelNPquadratic()){
10873 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10874 } else {
10875 return weight*(muProd)*(BrHXXRatio);
10876 }
10877
10878
10879}
10880
10881// -----------------------------------------------------------------------------
10882
10883//AG:STXS2024
10884STXS12_VHlep::STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10885: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10886{
10887 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10888 throw std::runtime_error("STXS12_VHlep called with a class whose parent is not NPbase");
10889
10890}
10891
10893{
10894 //-- Production:
10895 double weight = 1.0; //If normalized to the SM
10896 //Since adding bins, include partial weigths of SM_predictions
10897 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10898 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
10907 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10908 double muProd1 = ( 0.71256*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10909 + 0.06739*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)
10911 + 0.01127*(myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10912 + 0.00339*(myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0)
10913 + 0.07934*(myNPbase->STXS12_qqHll_pTV0_150(sqrt_s) -1.0)
10915 + 0.00746*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10916 + 0.00043*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )
10917 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10918 double muProd2 = 0.0;
10919
10920 //-- Decay:
10921 double BrHXXRatio = 1.0;
10922 double dBrHXXRatio1 = 0.0;
10923 double dBrHXXRatio2 = 0.0;
10924 if (fstate==0){
10925 weight = 1.0;
10926 } else if (fstate == 1){
10927 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10928 dBrHXXRatio1 = BrHXXRatio - 1.0;
10929 dBrHXXRatio2 = 0.0;
10930 } else if (fstate == 2){
10931 BrHXXRatio = (myNPbase->BrHgagaRatio());
10932 dBrHXXRatio1 = BrHXXRatio - 1.0;
10933 dBrHXXRatio2 = 0.0;
10934 } else if (fstate == 3){
10935 BrHXXRatio = (myNPbase->BrHbbRatio());
10936 dBrHXXRatio1 = BrHXXRatio - 1.0;
10937 dBrHXXRatio2 = 0.0;
10938 } else if (fstate == 4){
10939 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10940 dBrHXXRatio1 = BrHXXRatio - 1.0;
10941 dBrHXXRatio2 = 0.0;
10942 } else if (fstate == 5){
10943 BrHXXRatio = (myNPbase->BrHtautauRatio());
10944 dBrHXXRatio1 = BrHXXRatio - 1.0;
10945 dBrHXXRatio2 = 0.0;
10946 } else if (fstate == 6){
10947 BrHXXRatio = (myNPbase->BrHWWRatio());
10948 dBrHXXRatio1 = BrHXXRatio - 1.0;
10949 dBrHXXRatio2 = 0.0;
10950 } else if (fstate == 7){
10951 BrHXXRatio = (myNPbase->BrHZZRatio());
10952 dBrHXXRatio1 = BrHXXRatio - 1.0;
10953 dBrHXXRatio2 = 0.0;
10954 } else {
10955 throw std::runtime_error("STXS12_VHlep called with invalid argument for final state in fstate_i");
10956 }
10957
10958 //-- Production x Decay:
10959 if ((this->getModel()).isModelLinearized()){
10960 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10961 } else if((this->getModel()).isModelNPquadratic()){
10962 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10963 } else {
10964 return weight*(muProd)*(BrHXXRatio);
10965 }
10966
10967
10968}
10969
10970// -----------------------------------------------------------------------------
10971
10972//AG:STXS2024
10973STXS12_ttH_pTH0_60::STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10974: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10975{
10976 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10977 throw std::runtime_error("STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
10978
10979}
10980
10982{
10983 //-- Production:
10984 double weight = 1.0; //If normalized to the SM
10985 double muProd = myNPbase->STXS12_ttH_pTH0_60(sqrt_s) ;
10986 double muProd1 = muProd -1.0;
10987 double muProd2 = 0.0;
10988
10989 //-- Decay:
10990 double BrHXXRatio = 1.0;
10991 double dBrHXXRatio1 = 0.0;
10992 double dBrHXXRatio2 = 0.0;
10993 if (fstate==0){
10994 // Use for Cross-section [pb] with no Higgs-boson decay
10995 weight = 0.11821; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10996 } else if (fstate == 1){
10997 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10998 dBrHXXRatio1 = BrHXXRatio - 1.0;
10999 dBrHXXRatio2 = 0.0;
11000 } else if (fstate == 2){
11001 BrHXXRatio = (myNPbase->BrHgagaRatio());
11002 dBrHXXRatio1 = BrHXXRatio - 1.0;
11003 dBrHXXRatio2 = 0.0;
11004 } else if (fstate == 3){
11005 BrHXXRatio = (myNPbase->BrHbbRatio());
11006 dBrHXXRatio1 = BrHXXRatio - 1.0;
11007 dBrHXXRatio2 = 0.0;
11008 } else if (fstate == 4){
11009 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11010 dBrHXXRatio1 = BrHXXRatio - 1.0;
11011 dBrHXXRatio2 = 0.0;
11012 } else {
11013 throw std::runtime_error("STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
11014 }
11015
11016 //-- Production x Decay:
11017 if ((this->getModel()).isModelLinearized()){
11018 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11019 } else if((this->getModel()).isModelNPquadratic()){
11020 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11021 } else {
11022 return weight*(muProd)*(BrHXXRatio);
11023 }
11024
11025
11026}
11027
11028// -----------------------------------------------------------------------------
11029
11030//AG:STXS2024
11031STXS12_ttH_pTH60_120::STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11032: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11033{
11034 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11035 throw std::runtime_error("STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
11036
11037}
11038
11040{
11041 //-- Production:
11042 double weight = 1.0; //If normalized to the SM
11043 double muProd = myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ;
11044 double muProd1 = muProd -1.0;
11045 double muProd2 = 0.0;
11046
11047 //-- Decay:
11048 double BrHXXRatio = 1.0;
11049 double dBrHXXRatio1 = 0.0;
11050 double dBrHXXRatio2 = 0.0;
11051 if (fstate==0){
11052 // Use for Cross-section [pb] with no Higgs-boson decay
11053 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11054 } else if (fstate == 1){
11055 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11056 dBrHXXRatio1 = BrHXXRatio - 1.0;
11057 dBrHXXRatio2 = 0.0;
11058 } else if (fstate == 2){
11059 BrHXXRatio = (myNPbase->BrHgagaRatio());
11060 dBrHXXRatio1 = BrHXXRatio - 1.0;
11061 dBrHXXRatio2 = 0.0;
11062 } else if (fstate == 3){
11063 BrHXXRatio = (myNPbase->BrHbbRatio());
11064 dBrHXXRatio1 = BrHXXRatio - 1.0;
11065 dBrHXXRatio2 = 0.0;
11066 } else if (fstate == 4){
11067 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11068 dBrHXXRatio1 = BrHXXRatio - 1.0;
11069 dBrHXXRatio2 = 0.0;
11070 } else {
11071 throw std::runtime_error("STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
11072 }
11073
11074 //-- Production x Decay:
11075 if ((this->getModel()).isModelLinearized()){
11076 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11077 } else if((this->getModel()).isModelNPquadratic()){
11078 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11079 } else {
11080 return weight*(muProd)*(BrHXXRatio);
11081 }
11082
11083}
11084
11085// -----------------------------------------------------------------------------
11086
11087//AG:STXS2024
11088STXS12_ttH_pTH0_120::STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11089: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11090{
11091 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11092 throw std::runtime_error("STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
11093
11094}
11095
11097{
11098 //-- Production:
11099 double weight = 1.0; //If normalized to the SM
11100 //Since adding bins, include partial weigths of SM_predictions
11101 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11102 double muProd = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) )
11103 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ) )/(0.11821+0.17813);
11104 double muProd1 = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) -1.0)
11105 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0 ) )/(0.11821+0.17813);;
11106 double muProd2 = 0.0;
11107
11108 //-- Decay:
11109 double BrHXXRatio = 1.0;
11110 double dBrHXXRatio1 = 0.0;
11111 double dBrHXXRatio2 = 0.0;
11112 if (fstate==0){
11113 // Use for Cross-section [pb] with no Higgs-boson decay
11114 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11115 } else if (fstate == 1){
11116 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11117 dBrHXXRatio1 = BrHXXRatio - 1.0;
11118 dBrHXXRatio2 = 0.0;
11119 } else if (fstate == 2){
11120 BrHXXRatio = (myNPbase->BrHgagaRatio());
11121 dBrHXXRatio1 = BrHXXRatio - 1.0;
11122 dBrHXXRatio2 = 0.0;
11123 } else if (fstate == 3){
11124 BrHXXRatio = (myNPbase->BrHbbRatio());
11125 dBrHXXRatio1 = BrHXXRatio - 1.0;
11126 dBrHXXRatio2 = 0.0;
11127 } else if (fstate == 4){
11128 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11129 dBrHXXRatio1 = BrHXXRatio - 1.0;
11130 dBrHXXRatio2 = 0.0;
11131 } else {
11132 throw std::runtime_error("STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
11133 }
11134
11135 //-- Production x Decay:
11136 if ((this->getModel()).isModelLinearized()){
11137 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11138 } else if((this->getModel()).isModelNPquadratic()){
11139 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11140 } else {
11141 return weight*(muProd)*(BrHXXRatio);
11142 }
11143
11144}
11145
11146// -----------------------------------------------------------------------------
11147
11148//AG:STXS2024
11149STXS12_ttH_pTH120_200::STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11150: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11151{
11152 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11153 throw std::runtime_error("STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
11154
11155}
11156
11158{
11159 //-- Production:
11160 double weight = 1.0; //If normalized to the SM
11161 double muProd = myNPbase->STXS12_ttH_pTH120_200(sqrt_s) ;
11162 double muProd1 = muProd -1.0;
11163 double muProd2 = 0.0;
11164
11165 //-- Decay:
11166 double BrHXXRatio = 1.0;
11167 double dBrHXXRatio1 = 0.0;
11168 double dBrHXXRatio2 = 0.0;
11169 if (fstate==0){
11170 // Use for Cross-section [pb] with no Higgs-boson decay
11171 weight = 0.12647; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11172 } else if (fstate == 1){
11173 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11174 dBrHXXRatio1 = BrHXXRatio - 1.0;
11175 dBrHXXRatio2 = 0.0;
11176 } else if (fstate == 2){
11177 BrHXXRatio = (myNPbase->BrHgagaRatio());
11178 dBrHXXRatio1 = BrHXXRatio - 1.0;
11179 dBrHXXRatio2 = 0.0;
11180 } else if (fstate == 3){
11181 BrHXXRatio = (myNPbase->BrHbbRatio());
11182 dBrHXXRatio1 = BrHXXRatio - 1.0;
11183 dBrHXXRatio2 = 0.0;
11184 } else if (fstate == 4){
11185 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11186 dBrHXXRatio1 = BrHXXRatio - 1.0;
11187 dBrHXXRatio2 = 0.0;
11188 } else {
11189 throw std::runtime_error("STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
11190 }
11191
11192 //-- Production x Decay:
11193 if ((this->getModel()).isModelLinearized()){
11194 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11195 } else if((this->getModel()).isModelNPquadratic()){
11196 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11197 } else {
11198 return weight*(muProd)*(BrHXXRatio);
11199 }
11200
11201}
11202
11203// -----------------------------------------------------------------------------
11204
11205//AG:STXS2024
11206STXS12_ttH_pTH200_300::STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11207: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11208{
11209 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11210 throw std::runtime_error("STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
11211
11212}
11213
11215{
11216 //-- Production:
11217 double weight = 1.0; //If normalized to the SM
11218 double muProd = myNPbase->STXS12_ttH_pTH200_300(sqrt_s) ;
11219 double muProd1 = muProd -1.0;
11220 double muProd2 = 0.0;
11221
11222 //-- Decay:
11223 double BrHXXRatio = 1.0;
11224 double dBrHXXRatio1 = 0.0;
11225 double dBrHXXRatio2 = 0.0;
11226 if (fstate==0){
11227 // Use for Cross-section [pb] with no Higgs-boson decay
11228 weight = 0.05263; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11229 } else if (fstate == 1){
11230 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11231 dBrHXXRatio1 = BrHXXRatio - 1.0;
11232 dBrHXXRatio2 = 0.0;
11233 } else if (fstate == 2){
11234 BrHXXRatio = (myNPbase->BrHgagaRatio());
11235 dBrHXXRatio1 = BrHXXRatio - 1.0;
11236 dBrHXXRatio2 = 0.0;
11237 } else if (fstate == 3){
11238 BrHXXRatio = (myNPbase->BrHbbRatio());
11239 dBrHXXRatio1 = BrHXXRatio - 1.0;
11240 dBrHXXRatio2 = 0.0;
11241 } else if (fstate == 4){
11242 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11243 dBrHXXRatio1 = BrHXXRatio - 1.0;
11244 dBrHXXRatio2 = 0.0;
11245 } else {
11246 throw std::runtime_error("STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
11247 }
11248
11249 //-- Production x Decay:
11250 if ((this->getModel()).isModelLinearized()){
11251 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11252 } else if((this->getModel()).isModelNPquadratic()){
11253 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11254 } else {
11255 return weight*(muProd)*(BrHXXRatio);
11256 }
11257
11258}
11259
11260// -----------------------------------------------------------------------------
11261
11262STXS12_ttH_pTH300_Inf::STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11263: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11264{
11265 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11266 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
11267
11268}
11269
11271{
11272 //-- Production:
11273 double weight = 1.0; //If normalized to the SM
11274 double muProd = myNPbase->STXS12_ttH_pTH300_Inf(sqrt_s) ;
11275 double muProd1 = muProd -1.0;
11276 double muProd2 = 0.0;
11277
11278 //-- Decay:
11279 double BrHXXRatio = 1.0;
11280 double dBrHXXRatio1 = 0.0;
11281 double dBrHXXRatio2 = 0.0;
11282 if (fstate==0){
11283 // Use for Cross-section [pb] with no Higgs-boson decay
11284 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11285 } else if (fstate == 1){
11286 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11287 dBrHXXRatio1 = BrHXXRatio - 1.0;
11288 dBrHXXRatio2 = 0.0;
11289 } else if (fstate == 2){
11290 BrHXXRatio = (myNPbase->BrHgagaRatio());
11291 dBrHXXRatio1 = BrHXXRatio - 1.0;
11292 dBrHXXRatio2 = 0.0;
11293 } else if (fstate == 3){
11294 BrHXXRatio = (myNPbase->BrHbbRatio());
11295 dBrHXXRatio1 = BrHXXRatio - 1.0;
11296 dBrHXXRatio2 = 0.0;
11297 } else if (fstate == 4){
11298 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11299 dBrHXXRatio1 = BrHXXRatio - 1.0;
11300 dBrHXXRatio2 = 0.0;
11301 } else {
11302 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
11303 }
11304
11305 //-- Production x Decay:
11306 if ((this->getModel()).isModelLinearized()){
11307 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11308 } else if((this->getModel()).isModelNPquadratic()){
11309 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11310 } else {
11311 return weight*(muProd)*(BrHXXRatio);
11312 }
11313
11314
11315}
11316
11317// -----------------------------------------------------------------------------
11318
11319//AG:STXS2024
11320STXS12_ttH_pTH300_450::STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11321: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11322{
11323 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11324 throw std::runtime_error("STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
11325
11326}
11327
11329{
11330 //-- Production:
11331 double weight = 1.0; //If normalized to the SM
11332 double muProd = myNPbase->STXS12_ttH_pTH300_450(sqrt_s);
11333 double muProd1 = muProd -1.0;
11334 double muProd2 = 0.0;
11335
11336 //-- Decay:
11337 double BrHXXRatio = 1.0;
11338 double dBrHXXRatio1 = 0.0;
11339 double dBrHXXRatio2 = 0.0;
11340 if (fstate==0){
11341 // Use for Cross-section [pb] with no Higgs-boson decay
11342 weight = 0.01903; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11343 } else if (fstate == 1){
11344 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11345 dBrHXXRatio1 = BrHXXRatio - 1.0;
11346 dBrHXXRatio2 = 0.0;
11347 } else if (fstate == 2){
11348 BrHXXRatio = (myNPbase->BrHgagaRatio());
11349 dBrHXXRatio1 = BrHXXRatio - 1.0;
11350 dBrHXXRatio2 = 0.0;
11351 } else if (fstate == 3){
11352 BrHXXRatio = (myNPbase->BrHbbRatio());
11353 dBrHXXRatio1 = BrHXXRatio - 1.0;
11354 dBrHXXRatio2 = 0.0;
11355 } else if (fstate == 4){
11356 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11357 dBrHXXRatio1 = BrHXXRatio - 1.0;
11358 dBrHXXRatio2 = 0.0;
11359 } else if (fstate == 5){
11360 BrHXXRatio = (myNPbase->BrHtautauRatio());
11361 dBrHXXRatio1 = BrHXXRatio - 1.0;
11362 dBrHXXRatio2 = 0.0;
11363 } else {
11364 throw std::runtime_error("STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
11365 }
11366
11367 //-- Production x Decay:
11368 if ((this->getModel()).isModelLinearized()){
11369 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11370 } else if((this->getModel()).isModelNPquadratic()){
11371 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11372 } else {
11373 return weight*(muProd)*(BrHXXRatio);
11374 }
11375
11376}
11377// -----------------------------------------------------------------------------
11378
11379//AG:STXS2024
11380STXS12_ttH_pTH450_Inf::STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11381: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11382{
11383 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11384 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
11385
11386}
11387
11389{
11390 //-- Production:
11391 double weight = 1.0; //If normalized to the SM
11392 double muProd = myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s);
11393 double muProd1 = muProd -1.0;
11394 double muProd2 = 0.0;
11395
11396 //-- Decay:
11397 double BrHXXRatio = 1.0;
11398 double dBrHXXRatio1 = 0.0;
11399 double dBrHXXRatio2 = 0.0;
11400 if (fstate==0){
11401 // Use for Cross-section [pb] with no Higgs-boson decay
11402 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11403 } else if (fstate == 1){
11404 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11405 dBrHXXRatio1 = BrHXXRatio - 1.0;
11406 dBrHXXRatio2 = 0.0;
11407 } else if (fstate == 2){
11408 BrHXXRatio = (myNPbase->BrHgagaRatio());
11409 dBrHXXRatio1 = BrHXXRatio - 1.0;
11410 dBrHXXRatio2 = 0.0;
11411 } else if (fstate == 3){
11412 BrHXXRatio = (myNPbase->BrHbbRatio());
11413 dBrHXXRatio1 = BrHXXRatio - 1.0;
11414 dBrHXXRatio2 = 0.0;
11415 } else if (fstate == 4){
11416 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11417 dBrHXXRatio1 = BrHXXRatio - 1.0;
11418 dBrHXXRatio2 = 0.0;
11419 } else if (fstate == 5){
11420 BrHXXRatio = (myNPbase->BrHtautauRatio());
11421 dBrHXXRatio1 = BrHXXRatio - 1.0;
11422 dBrHXXRatio2 = 0.0;
11423 } else {
11424 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
11425 }
11426
11427 //-- Production x Decay:
11428 if ((this->getModel()).isModelLinearized()){
11429 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11430 } else if((this->getModel()).isModelNPquadratic()){
11431 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11432 } else {
11433 return weight*(muProd)*(BrHXXRatio);
11434 }
11435
11436}
11437
11438// -----------------------------------------------------------------------------
11439
11440//AG:STXS2024
11441STXS12_ttH_pTH300_Inf_add::STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11442: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11443{
11444 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11445 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
11446
11447}
11448
11450{
11451 //-- Production:
11452 double weight = 1.0; //If normalized to the SM
11453 //Since adding bins, include partial weigths of SM_predictions
11454 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11455 double muProd = (0.01903*myNPbase->STXS12_ttH_pTH300_450(sqrt_s)
11456 + 0.00538*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)) / (0.01903+0.00538);
11457 double muProd1 = (0.01903*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11458 + 0.00538*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0)) / (0.01903+0.00538);
11459 double muProd2 = 0.0;
11460
11461 //-- Decay:
11462 double BrHXXRatio = 1.0;
11463 double dBrHXXRatio1 = 0.0;
11464 double dBrHXXRatio2 = 0.0;
11465 if (fstate==0){
11466 // Use for Cross-section [pb] with no Higgs-boson decay
11467 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11468 } else if (fstate == 1){
11469 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11470 dBrHXXRatio1 = BrHXXRatio - 1.0;
11471 dBrHXXRatio2 = 0.0;
11472 } else if (fstate == 2){
11473 BrHXXRatio = (myNPbase->BrHgagaRatio());
11474 dBrHXXRatio1 = BrHXXRatio - 1.0;
11475 dBrHXXRatio2 = 0.0;
11476 } else if (fstate == 3){
11477 BrHXXRatio = (myNPbase->BrHbbRatio());
11478 dBrHXXRatio1 = BrHXXRatio - 1.0;
11479 dBrHXXRatio2 = 0.0;
11480 } else if (fstate == 4){
11481 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11482 dBrHXXRatio1 = BrHXXRatio - 1.0;
11483 dBrHXXRatio2 = 0.0;
11484 } else if (fstate == 5){
11485 BrHXXRatio = (myNPbase->BrHtautauRatio());
11486 dBrHXXRatio1 = BrHXXRatio - 1.0;
11487 dBrHXXRatio2 = 0.0;
11488 } else {
11489 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
11490 }
11491
11492 //-- Production x Decay:
11493 if ((this->getModel()).isModelLinearized()){
11494 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11495 } else if((this->getModel()).isModelNPquadratic()){
11496 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11497 } else {
11498 return weight*(muProd)*(BrHXXRatio);
11499 }
11500
11501}
11502
11503// -----------------------------------------------------------------------------
11504
11505//AG:STXS2024
11506STXS12_ttH::STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11507: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11508{
11509 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11510 throw std::runtime_error("STXS12_ttH called with a class whose parent is not NPbase");
11511
11512}
11513
11515{
11516 //-- Production:
11517 double weight = 1.0; //If normalized to the SM
11518 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11519 //Since adding bins, include partial weigths (SM_predictions)
11520 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
11525 + 0.00060*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11526 double muProd1 = ( 0.09779*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s)-1.0)
11527 + 0.13884*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0)
11528 + 0.05439*(myNPbase->STXS12_ttH_pTH120_200(sqrt_s)-1.0)
11529 + 0.05303*(myNPbase->STXS12_ttH_pTH200_300(sqrt_s)-1.0)
11530 + 0.00498*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11531 + 0.00060*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11532 double muProd2 = 0.0;
11533
11534 //-- Decay:
11535 double BrHXXRatio = 1.0;
11536 double dBrHXXRatio1 = 0.0;
11537 double dBrHXXRatio2 = 0.0;
11538 if (fstate==0){
11539 weight = 1.0;
11540 } else if (fstate == 1){
11541 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11542 dBrHXXRatio1 = BrHXXRatio - 1.0;
11543 dBrHXXRatio2 = 0.0;
11544 } else if (fstate == 2){
11545 BrHXXRatio = (myNPbase->BrHgagaRatio());
11546 dBrHXXRatio1 = BrHXXRatio - 1.0;
11547 dBrHXXRatio2 = 0.0;
11548 } else if (fstate == 3){
11549 BrHXXRatio = (myNPbase->BrHbbRatio());
11550 dBrHXXRatio1 = BrHXXRatio - 1.0;
11551 dBrHXXRatio2 = 0.0;
11552 } else if (fstate == 4){
11553 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11554 dBrHXXRatio1 = BrHXXRatio - 1.0;
11555 dBrHXXRatio2 = 0.0;
11556 } else if (fstate == 5){
11557 BrHXXRatio = (myNPbase->BrHtautauRatio());
11558 dBrHXXRatio1 = BrHXXRatio - 1.0;
11559 dBrHXXRatio2 = 0.0;
11560 } else if (fstate == 6){
11561 BrHXXRatio = (myNPbase->BrHWWRatio());
11562 dBrHXXRatio1 = BrHXXRatio - 1.0;
11563 dBrHXXRatio2 = 0.0;
11564 } else if (fstate == 7){
11565 BrHXXRatio = (myNPbase->BrHZZRatio());
11566 dBrHXXRatio1 = BrHXXRatio - 1.0;
11567 dBrHXXRatio2 = 0.0;
11568 } else {
11569 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
11570 }
11571
11572 //-- Production x Decay:
11573 if ((this->getModel()).isModelLinearized()){
11574 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11575 } else if((this->getModel()).isModelNPquadratic()){
11576 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11577 } else {
11578 return weight*(muProd)*(BrHXXRatio);
11579 }
11580
11581}
11582
11583// -----------------------------------------------------------------------------
11584
11585//AG:STXS2024
11586STXS12_tH::STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11587: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11588{
11589 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11590 throw std::runtime_error("STXS12_tH called with a class whose parent is not NPbase");
11591
11592}
11593
11594double STXS12_tH::computeThValue() //AG:modified
11595{
11596 //-- Production:
11597 double weight = 1.0; //If normalized to the SM
11598 double muProd = myNPbase->STXS12_tH(sqrt_s);
11599 double muProd1 = muProd -1.0;
11600 double muProd2 = 0.0;
11601
11602 //-- Decay:
11603 double BrHXXRatio = 1.0;
11604 double dBrHXXRatio1 = 0.0;
11605 double dBrHXXRatio2 = 0.0;
11606 if (fstate==0){
11607 // Use for Cross-section [pb] with no Higgs-boson decay
11608 weight = 0.08207; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11609 } else if (fstate == 1){
11610 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11611 dBrHXXRatio1 = BrHXXRatio - 1.0;
11612 dBrHXXRatio2 = 0.0;
11613 } else if (fstate == 2){
11614 BrHXXRatio = (myNPbase->BrHgagaRatio());
11615 dBrHXXRatio1 = BrHXXRatio - 1.0;
11616 dBrHXXRatio2 = 0.0;
11617 } else if (fstate == 3){
11618 BrHXXRatio = (myNPbase->BrHbbRatio());
11619 dBrHXXRatio1 = BrHXXRatio - 1.0;
11620 dBrHXXRatio2 = 0.0;
11621 } else if (fstate == 4){
11622 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11623 dBrHXXRatio1 = BrHXXRatio - 1.0;
11624 dBrHXXRatio2 = 0.0;
11625 } else if (fstate == 5){
11626 BrHXXRatio = (myNPbase->BrHtautauRatio());
11627 dBrHXXRatio1 = BrHXXRatio - 1.0;
11628 dBrHXXRatio2 = 0.0;
11629 } else {
11630 throw std::runtime_error("STXS12_tH called with invalid argument for final state in fstate_i");
11631 }
11632
11633 //-- Production x Decay:
11634 if ((this->getModel()).isModelLinearized()){
11635 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11636 } else if((this->getModel()).isModelNPquadratic()){
11637 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11638 } else {
11639 return weight*(muProd)*(BrHXXRatio);
11640 }
11641
11642
11643}
11644
11645// -----------------------------------------------------------------------------
11646
11647
11648//-----------------------------------------------------------------------------------------
11649//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
11650//-----------------------------------------------------------------------------------------
11651
11652
11653muTHUggHgaga::muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11654: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11655{
11656 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11657 throw std::runtime_error("muTHUggHgaga called with a class whose parent is not NPbase");
11658}
11659
11661{
11662 return myNPbase->muTHUggHgaga(sqrt_s);
11663}
11664
11665
11666muTHUVBFHgaga::muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11667: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11668{
11669 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11670 throw std::runtime_error("muTHUVBFHgaga called with a class whose parent is not NPbase");
11671}
11672
11674{
11675 return myNPbase->muTHUVBFHgaga(sqrt_s);
11676}
11677
11678muTHUZHgaga::muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11679: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11680{
11681 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11682 throw std::runtime_error("muTHUZHgaga called with a class whose parent is not NPbase");
11683}
11684
11686{
11687 return myNPbase->muTHUZHgaga(sqrt_s);
11688}
11689
11690muTHUWHgaga::muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11691: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11692{
11693 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11694 throw std::runtime_error("muTHUWHgaga called with a class whose parent is not NPbase");
11695}
11696
11698{
11699 return myNPbase->muTHUWHgaga(sqrt_s);
11700}
11701
11702muTHUVHgaga::muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11703: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11704{
11705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11706 throw std::runtime_error("muTHUVHgaga called with a class whose parent is not NPbase");
11707}
11708
11710{
11711 return myNPbase->muTHUVHgaga(sqrt_s);
11712}
11713
11714muTHUttHgaga::muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11715: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11716{
11717 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11718 throw std::runtime_error("muTHUttHgaga called with a class whose parent is not NPbase");
11719}
11720
11722{
11723 return myNPbase->muTHUttHgaga(sqrt_s);
11724}
11725
11726muTHUggHZga::muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i)
11727: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11728{
11729 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11730 throw std::runtime_error("muTHUggHZga called with a class whose parent is not NPbase");
11731}
11732
11734{
11735 return myNPbase->muTHUggHZga(sqrt_s);
11736}
11737
11738muTHUggHZgamumu::muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
11739: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11740{
11741 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11742 throw std::runtime_error("muTHUggHZgamumu called with a class whose parent is not NPbase");
11743}
11744
11746{
11747 return (myNPbase->muTHUggHZgamumu(sqrt_s));
11748}
11749
11750muTHUVBFHZga::muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
11751: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11752{
11753 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11754 throw std::runtime_error("muTHUVBFHZga called with a class whose parent is not NPbase");
11755}
11756
11758{
11759
11760 return myNPbase->muTHUVBFHZga(sqrt_s);
11761}
11762
11763muTHUZHZga::muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i)
11764: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11765{
11766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11767 throw std::runtime_error("muTHUZHZga called with a class whose parent is not NPbase");
11768}
11769
11771{
11772 return myNPbase->muTHUZHZga(sqrt_s);
11773}
11774
11775muTHUWHZga::muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i)
11776: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11777{
11778 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11779 throw std::runtime_error("muTHUWHZga called with a class whose parent is not NPbase");
11780}
11781
11783{
11784 return myNPbase->muTHUWHZga(sqrt_s);
11785}
11786
11787muTHUVHZga::muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i)
11788: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11789{
11790 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11791 throw std::runtime_error("muTHUVHZga called with a class whose parent is not NPbase");
11792}
11793
11795{
11796 return myNPbase->muTHUVHZga(sqrt_s);
11797}
11798
11799muTHUttHZga::muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i)
11800: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11801{
11802 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11803 throw std::runtime_error("muTHUttHZga called with a class whose parent is not NPbase");
11804}
11805
11807{
11808 return myNPbase->muTHUttHZga(sqrt_s);
11809}
11810
11811muTHUggHZZ::muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11812: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11813{
11814 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11815 throw std::runtime_error("muTHUggHZZ called with a class whose parent is not NPbase");
11816}
11817
11819{
11820 return myNPbase->muTHUggHZZ(sqrt_s);
11821}
11822
11823muTHUVBFHZZ::muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11824: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11825{
11826 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11827 throw std::runtime_error("muTHUVBFHZZ called with a class whose parent is not NPbase");
11828}
11829
11831{
11832 return myNPbase->muTHUVBFHZZ(sqrt_s);
11833}
11834
11835muTHUZHZZ::muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11836: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11837{
11838 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11839 throw std::runtime_error("muTHUZHZZ called with a class whose parent is not NPbase");
11840}
11841
11843{
11844 return myNPbase->muTHUZHZZ(sqrt_s);
11845}
11846
11847muTHUWHZZ::muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11848: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11849{
11850 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11851 throw std::runtime_error("muTHUWHZZ called with a class whose parent is not NPbase");
11852}
11853
11855{
11856 return myNPbase->muTHUWHZZ(sqrt_s);
11857}
11858
11859muTHUVHZZ::muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11860: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11861{
11862 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11863 throw std::runtime_error("muTHUVHZZ called with a class whose parent is not NPbase");
11864}
11865
11867{
11868 return myNPbase->muTHUVHZZ(sqrt_s);
11869}
11870
11871muTHUttHZZ::muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11872: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11873{
11874 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11875 throw std::runtime_error("muTHUttHZZ called with a class whose parent is not NPbase");
11876}
11877
11879{
11880 return myNPbase->muTHUttHZZ(sqrt_s);
11881}
11882
11883muTHUggHZZ4l::muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11884: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11885{
11886 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11887 throw std::runtime_error("muTHUggHZZ4l called with a class whose parent is not NPbase");
11888}
11889
11891{
11892 return myNPbase->muTHUggHZZ4l(sqrt_s);
11893}
11894
11895muTHUggHZZ4mu::muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
11896: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11897{
11898 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11899 throw std::runtime_error("muTHUggHZZ4mu called with a class whose parent is not NPbase");
11900}
11901
11903{
11904 return (myNPbase->muTHUggHZZ4mu(sqrt_s));
11905}
11906
11907muTHUVBFHZZ4l::muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11908: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11909{
11910 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11911 throw std::runtime_error("muTHUVBFHZZ4l called with a class whose parent is not NPbase");
11912}
11913
11915{
11916 return myNPbase->muTHUVBFHZZ4l(sqrt_s);
11917}
11918
11919muTHUZHZZ4l::muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11920: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11921{
11922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11923 throw std::runtime_error("muTHUZHZZ4l called with a class whose parent is not NPbase");
11924}
11925
11927{
11928 return myNPbase->muTHUZHZZ4l(sqrt_s);
11929}
11930
11931muTHUWHZZ4l::muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11932: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11933{
11934 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11935 throw std::runtime_error("muTHUWHZZ4l called with a class whose parent is not NPbase");
11936}
11937
11939{
11940 return myNPbase->muTHUWHZZ4l(sqrt_s);
11941}
11942
11943muTHUVHZZ4l::muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11944: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11945{
11946 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11947 throw std::runtime_error("muTHUVHZZ4l called with a class whose parent is not NPbase");
11948}
11949
11951{
11952 return myNPbase->muTHUVHZZ4l(sqrt_s);
11953}
11954
11955muTHUttHZZ4l::muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11956: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11957{
11958 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11959 throw std::runtime_error("muTHUttHZZ4l called with a class whose parent is not NPbase");
11960}
11961
11963{
11964 return myNPbase->muTHUttHZZ4l(sqrt_s);
11965}
11966
11967muTHUggHWW::muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i)
11968: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11969{
11970 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11971 throw std::runtime_error("muTHUggHWW called with a class whose parent is not NPbase");
11972}
11973
11975{
11976 return myNPbase->muTHUggHWW(sqrt_s);
11977}
11978
11979muTHUVBFHWW::muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
11980: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11981{
11982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11983 throw std::runtime_error("muTHUVBFHWW called with a class whose parent is not NPbase");
11984}
11985
11987{
11988 return myNPbase->muTHUVBFHWW(sqrt_s);
11989}
11990
11991muTHUZHWW::muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i)
11992: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11993{
11994 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11995 throw std::runtime_error("muTHUZHWW called with a class whose parent is not NPbase");
11996}
11997
11999{
12000 return myNPbase->muTHUZHWW(sqrt_s);
12001}
12002
12003muTHUWHWW::muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i)
12004: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12005{
12006 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12007 throw std::runtime_error("muTHUWHWW called with a class whose parent is not NPbase");
12008}
12009
12011{
12012 return myNPbase->muTHUWHWW(sqrt_s);
12013}
12014
12015muTHUVHWW::muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i)
12016: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12017{
12018 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12019 throw std::runtime_error("muTHUVHWW called with a class whose parent is not NPbase");
12020}
12021
12023{
12024 return myNPbase->muTHUVHWW(sqrt_s);
12025}
12026
12027muTHUttHWW::muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i)
12028: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12029{
12030 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12031 throw std::runtime_error("muTHUttHWW called with a class whose parent is not NPbase");
12032}
12033
12035{
12036 return myNPbase->muTHUttHWW(sqrt_s);
12037}
12038
12039muTHUggHWW2l2v::muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12040: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12041{
12042 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12043 throw std::runtime_error("muTHUggHWW2l2v called with a class whose parent is not NPbase");
12044}
12045
12047{
12049}
12050
12051muTHUVBFHWW2l2v::muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12052: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12053{
12054 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12055 throw std::runtime_error("muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
12056}
12057
12059{
12061}
12062
12063muTHUZHWW2l2v::muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12064: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12065{
12066 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12067 throw std::runtime_error("muTHUZHWW2l2v called with a class whose parent is not NPbase");
12068}
12069
12071{
12072 return myNPbase->muTHUZHWW2l2v(sqrt_s);
12073}
12074
12075muTHUWHWW2l2v::muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12076: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12077{
12078 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12079 throw std::runtime_error("muTHUWHWW2l2v called with a class whose parent is not NPbase");
12080}
12081
12083{
12084 return myNPbase->muTHUWHWW2l2v(sqrt_s);
12085}
12086
12087muTHUVHWW2l2v::muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12088: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12089{
12090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12091 throw std::runtime_error("muTHUVHWW2l2v called with a class whose parent is not NPbase");
12092}
12093
12095{
12096 return myNPbase->muTHUVHWW2l2v(sqrt_s);
12097}
12098
12099muTHUttHWW2l2v::muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12100: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12101{
12102 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12103 throw std::runtime_error("muTHUttHWW2l2v called with a class whose parent is not NPbase");
12104}
12105
12107{
12109}
12110
12111muTHUggHmumu::muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12112: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12113{
12114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12115 throw std::runtime_error("muTHUggHmumu called with a class whose parent is not NPbase");
12116}
12117
12119{
12120 return myNPbase->muTHUggHmumu(sqrt_s);
12121}
12122
12123muTHUVBFHmumu::muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12125{
12126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12127 throw std::runtime_error("muTHUVBFHmumu called with a class whose parent is not NPbase");
12128}
12129
12131{
12132 return myNPbase->muTHUVBFHmumu(sqrt_s);
12133}
12134
12135muTHUZHmumu::muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12136: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12137{
12138 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12139 throw std::runtime_error("muTHUZHmumu called with a class whose parent is not NPbase");
12140}
12141
12143{
12144 return myNPbase->muTHUZHmumu(sqrt_s);
12145}
12146
12147muTHUWHmumu::muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12148: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12149{
12150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12151 throw std::runtime_error("muTHUWHmumu called with a class whose parent is not NPbase");
12152}
12153
12155{
12156 return myNPbase->muTHUWHmumu(sqrt_s);
12157}
12158
12159muTHUVHmumu::muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12160: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12161{
12162 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12163 throw std::runtime_error("muTHUVHmumu called with a class whose parent is not NPbase");
12164}
12165
12167{
12168 return myNPbase->muTHUVHmumu(sqrt_s);
12169}
12170
12171muTHUttHmumu::muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12172: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12173{
12174 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12175 throw std::runtime_error("muTHUttHmumu called with a class whose parent is not NPbase");
12176}
12177
12179{
12180 return myNPbase->muTHUttHmumu(sqrt_s);
12181}
12182
12183muTHUggHtautau::muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12184: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12185{
12186 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12187 throw std::runtime_error("muTHUggHtautau called with a class whose parent is not NPbase");
12188}
12189
12191{
12193}
12194
12195muTHUVBFHtautau::muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12196: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12197{
12198 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12199 throw std::runtime_error("muTHUVBFHtautau called with a class whose parent is not NPbase");
12200}
12201
12203{
12205}
12206
12207muTHUZHtautau::muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12208: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12209{
12210 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12211 throw std::runtime_error("muTHUZHtautau called with a class whose parent is not NPbase");
12212}
12213
12215{
12216 return myNPbase->muTHUZHtautau(sqrt_s);
12217}
12218
12219muTHUWHtautau::muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12220: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12221{
12222 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12223 throw std::runtime_error("muTHUWHtautau called with a class whose parent is not NPbase");
12224}
12225
12227{
12228 return myNPbase->muTHUWHtautau(sqrt_s);
12229}
12230
12231muTHUVHtautau::muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12232: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12233{
12234 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12235 throw std::runtime_error("muTHUVHtautau called with a class whose parent is not NPbase");
12236}
12237
12239{
12240 return myNPbase->muTHUVHtautau(sqrt_s);
12241}
12242
12243muTHUttHtautau::muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12244: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12245{
12246 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12247 throw std::runtime_error("muTHUttHtautau called with a class whose parent is not NPbase");
12248}
12249
12251{
12253}
12254
12255muTHUggHbb::muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i)
12256: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12257{
12258 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12259 throw std::runtime_error("muTHUggHbb called with a class whose parent is not NPbase");
12260}
12261
12263{
12264 return myNPbase->muTHUggHbb(sqrt_s);
12265}
12266
12267muTHUVBFHbb::muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
12268: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12269{
12270 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12271 throw std::runtime_error("muTHUVBFHbb called with a class whose parent is not NPbase");
12272}
12273
12275{
12276 return myNPbase->muTHUVBFHbb(sqrt_s);
12277}
12278
12279muTHUZHbb::muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i)
12280: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12281{
12282 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12283 throw std::runtime_error("muTHUZHbb called with a class whose parent is not NPbase");
12284}
12285
12287{
12288 return myNPbase->muTHUZHbb(sqrt_s);
12289}
12290
12291muTHUWHbb::muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i)
12292: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12293{
12294 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12295 throw std::runtime_error("muTHUWHbb called with a class whose parent is not NPbase");
12296}
12297
12299{
12300 return myNPbase->muTHUWHbb(sqrt_s);
12301}
12302
12303muTHUVHbb::muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i)
12304: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12305{
12306 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12307 throw std::runtime_error("muTHUVHbb called with a class whose parent is not NPbase");
12308}
12309
12311{
12312 return myNPbase->muTHUVHbb(sqrt_s);
12313}
12314
12315muTHUttHbb::muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i)
12316: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12317{
12318 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12319 throw std::runtime_error("muTHUttHbb called with a class whose parent is not NPbase");
12320}
12321
12323{
12324 return myNPbase->muTHUttHbb(sqrt_s);
12325}
12326
12327
12328muTHUVBFBRinv::muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12329: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12330{
12331 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12332 throw std::runtime_error("muTHUVBFBRinv called with a class whose parent is not NPbase");
12333}
12334
12336{
12337
12338 return (myNPbase->muTHUVBFBRinv(sqrt_s));
12339
12340}
12341
12342muTHUVBFHinv::muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
12343: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12344{
12345 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12346 throw std::runtime_error("muTHUVBFHinv called with a class whose parent is not NPbase");
12347}
12348
12350{
12351
12352 return (myNPbase->muTHUVBFHinv(sqrt_s));
12353
12354}
12355
12356
12357muTHUVHBRinv::muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12358: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12359{
12360 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12361 throw std::runtime_error("muTHUVHBRinv called with a class whose parent is not NPbase");
12362}
12363
12365{
12366
12367 return (myNPbase->muTHUVHBRinv(sqrt_s));
12368
12369}
12370
12371muTHUVHinv::muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i)
12372: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12373{
12374 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12375 throw std::runtime_error("muTHUVHinv called with a class whose parent is not NPbase");
12376}
12377
12379{
12380 return (myNPbase->muTHUVHinv(sqrt_s));
12381}
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
const NPbase * myNPbase
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
const NPbase * myNPbase
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
virtual const double muggHbb(const double sqrt_s) const
Definition: NPbase.h:1647
virtual const double muVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1571
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3699
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3304
virtual const double cbminuscc() const
Definition: NPbase.h:2493
virtual const double muTHUZHmumu(const double sqrt_s) const
Definition: NPbase.h:2679
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3974
virtual const double deltaGammaHtautauRatio1() const
Definition: NPbase.h:1828
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4064
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2166
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:972
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3595
virtual const double muTHUttHWW(const double sqrt_s) const
Definition: NPbase.h:2643
virtual const double muTHUttHZga(const double sqrt_s) const
Definition: NPbase.h:2569
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2274
virtual const double muTHUttHbb(const double sqrt_s) const
Definition: NPbase.h:2739
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3710
virtual const double muggHZga(const double sqrt_s) const
Definition: NPbase.h:1442
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3084
virtual const double cVpluscb() const
Definition: NPbase.h:2475
virtual const double deltaGammaHtautauRatio2() const
Definition: NPbase.h:1832
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3604
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1191
virtual const double muttHptH_HWW(const double sqrt_s) const
Definition: NPbase.h:1551
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:947
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3771
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3857
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3689
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3130
virtual const double delta_mutH_2(const double sqrt_s) const
Definition: NPbase.h:1751
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: NPbase.h:1226
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: NPbase.h:923
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1916
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3803
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1331
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1022
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3179
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1367
virtual const double muttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1518
virtual const double muVHZga(const double sqrt_s) const
Definition: NPbase.h:1458
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1619
virtual const double muTHUZHZZ(const double sqrt_s) const
Definition: NPbase.h:2581
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3333
virtual const double muZHmumu(const double sqrt_s) const
Definition: NPbase.h:1587
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3956
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
Definition: NPbase.h:3481
virtual const double ccminusctau() const
Definition: NPbase.h:2511
virtual const double muTHUttHZZ(const double sqrt_s) const
Definition: NPbase.h:2593
virtual const double mueeZH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1090
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3848
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3209
virtual const double muVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:1583
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4091
virtual const double muggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1498
virtual const double delta_muZH_2(const double sqrt_s) const
Definition: NPbase.h:1724
virtual const double cgaplusct() const
Definition: NPbase.h:2457
virtual const double muTHUVBFBRinv(const double sqrt_s) const
Definition: NPbase.h:2744
virtual const double muTHUVBFHZga(const double sqrt_s) const
Definition: NPbase.h:2553
virtual const double deltaGammaHbbRatio2() const
Definition: NPbase.h:1814
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1056
virtual const double muttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1575
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3121
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4073
virtual const double STXS12_qqHqq_VH_had_Nj2(const double sqrt_s) const
The STXS bin , VH-had Ref. 2402.05742.
Definition: NPbase.h:3793
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1906
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: NPbase.h:1271
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3812
virtual const double muTHUVHBRinv(const double sqrt_s) const
Definition: NPbase.h:2754
virtual const double delta_mutH_1(const double sqrt_s) const
Definition: NPbase.h:1747
virtual const double muTHUZHgaga(const double sqrt_s) const
Definition: NPbase.h:2533
virtual const double muTHUggHZZ(const double sqrt_s) const
Definition: NPbase.h:2573
virtual const double muTHUVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:2577
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3490
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3753
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1607
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3866
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3902
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2647
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3159
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3929
virtual const double muVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:1474
virtual const double muTHUggHWW(const double sqrt_s) const
Definition: NPbase.h:2623
virtual const double cgplusct() const
Definition: NPbase.h:2448
virtual const double muttHtautau(const double sqrt_s) const
Definition: NPbase.h:1639
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3444
virtual const double muTHUggHZga(const double sqrt_s) const
Definition: NPbase.h:2549
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1283
virtual const double muTHUZHbb(const double sqrt_s) const
Definition: NPbase.h:2727
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3722
virtual const double muVBFHWW(const double sqrt_s) const
Definition: NPbase.h:1531
virtual const double muWHWW(const double sqrt_s) const
Definition: NPbase.h:1539
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4010
virtual const double muVBFHZga(const double sqrt_s) const
Definition: NPbase.h:1446
virtual const double muVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1559
virtual const double deltaGammaTotalRatio1() const
Definition: NPbase.h:1846
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3577
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
Definition: NPbase.h:3457
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3893
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3417
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2067
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2031
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2009
virtual const double muggHgaga(const double sqrt_s) const
Definition: NPbase.h:1384
virtual const double muVHcc(const double sqrt_s) const
Definition: NPbase.h:1679
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1140
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3517
virtual const double muttHptH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1402
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3313
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:1926
virtual const double deltaGammaHZgaRatio2() const
Definition: NPbase.h:1805
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3499
virtual const double deltaGammaHmumuRatio1() const
Definition: NPbase.h:1819
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3965
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4001
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3372
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3323
virtual const double muTHUWHbb(const double sqrt_s) const
Definition: NPbase.h:2731
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3353
virtual const double muTHUVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2614
virtual const double muppHmumu(const double sqrt_s) const
Definition: NPbase.h:1683
virtual const double muTHUVHinv(const double sqrt_s) const
Definition: NPbase.h:2759
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2353
virtual const double delta_muttH_2(const double sqrt_s) const
Definition: NPbase.h:1742
virtual const double muZHZga(const double sqrt_s) const
Definition: NPbase.h:1450
virtual const double deltaGammaHmumuRatio2() const
Definition: NPbase.h:1823
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3103
virtual const double muZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1563
virtual const double muttHWW(const double sqrt_s) const
Definition: NPbase.h:1547
virtual const double muVHZZ(const double sqrt_s) const
Definition: NPbase.h:1486
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4118
virtual const double deltaGammaHZgaRatio1() const
Definition: NPbase.h:1801
virtual const double deltaGammaHWWRatio1() const
Definition: NPbase.h:1774
virtual const double muTHUVHgaga(const double sqrt_s) const
Definition: NPbase.h:2541
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3199
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1470
virtual const double delta_muggH_1(const double sqrt_s) const
Definition: NPbase.h:1693
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3343
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1067
virtual const double delta_muVBF_1(const double sqrt_s) const
Definition: NPbase.h:1702
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3640
virtual const double deltaGammaHZZRatio1() const
Definition: NPbase.h:1783
virtual const double muTHUVHWW(const double sqrt_s) const
Definition: NPbase.h:2639
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3408
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1896
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3218
virtual const double muWHZga(const double sqrt_s) const
Definition: NPbase.h:1454
virtual const double muTHUttHtautau(const double sqrt_s) const
Definition: NPbase.h:2715
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1611
virtual const double muttHptH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1494
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2663
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1296
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3508
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2403
virtual const double muTHUttHgaga(const double sqrt_s) const
Definition: NPbase.h:2545
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2283
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3074
virtual const double muggHmumu(const double sqrt_s) const
Definition: NPbase.h:1579
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:985
virtual const double muggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1555
virtual const double muttHptH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1643
virtual const double STXS12_ttH_pTH300_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4127
virtual const double muZHbb(const double sqrt_s) const
Definition: NPbase.h:1659
virtual const double deltaGammaTotalRatio2() const
Definition: NPbase.h:1850
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3744
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3295
virtual const double muWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1567
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3735
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3667
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3390
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3426
virtual const double muZHtautau(const double sqrt_s) const
Definition: NPbase.h:1627
virtual const double muTHUVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:2529
virtual const double deltaGammaHgagaRatio2() const
Definition: NPbase.h:1796
virtual const double muTHUWHWW(const double sqrt_s) const
Definition: NPbase.h:2635
virtual const double deltaGammaHgagaRatio1() const
Definition: NPbase.h:1792
virtual const double mutHgaga(const double sqrt_s) const
Definition: NPbase.h:1390
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2659
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3631
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1153
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3545
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1999
virtual const double delta_muttH_1(const double sqrt_s) const
Definition: NPbase.h:1738
virtual const double muZHgaga(const double sqrt_s) const
Definition: NPbase.h:1426
virtual const double UpperLimitZgammaC(const double sqrt_s) const
Definition: NPbase.h:2439
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2304
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3227
virtual const double muWHgaga(const double sqrt_s) const
Definition: NPbase.h:1430
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
Definition: NPbase.h:3465
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3255
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: NPbase.h:2373
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4136
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1876
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3649
virtual const double muVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1502
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1307
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
Definition: NPbase.h:1319
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3139
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3678
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1956
virtual const double muVBFHbb(const double sqrt_s) const
Definition: NPbase.h:1655
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3821
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:997
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3112
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
Definition: NPbase.h:2412
virtual const double muTHUVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:2675
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3622
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4019
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
Definition: NPbase.h:2764
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:1864
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3658
virtual const double muTHUWHtautau(const double sqrt_s) const
Definition: NPbase.h:2707
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2602
virtual const double muZHWW(const double sqrt_s) const
Definition: NPbase.h:1535
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3830
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3875
virtual const double cbminusctau() const
Definition: NPbase.h:2502
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2335
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: NPbase.h:1215
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2076
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:960
virtual const double muTHUttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2618
virtual const double muWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1510
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
Definition: NPbase.h:2421
virtual const double mueeZHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1127
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2667
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3762
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1010
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3613
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
Definition: NPbase.h:2364
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1396
virtual const double muWHbb(const double sqrt_s) const
Definition: NPbase.h:1663
virtual const double muVHWW(const double sqrt_s) const
Definition: NPbase.h:1543
virtual const double muTHUVHZZ(const double sqrt_s) const
Definition: NPbase.h:2589
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
Definition: NPbase.h:912
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3169
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: NPbase.h:1379
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3189
virtual const double muTHUWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2610
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3381
virtual const double deltaGammaHZZRatio2() const
Definition: NPbase.h:1787
virtual const double muWHtautau(const double sqrt_s) const
Definition: NPbase.h:1631
virtual const double muTHUggHtautau(const double sqrt_s) const
Definition: NPbase.h:2695
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3556
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3911
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1936
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3399
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2220
virtual const double muTHUVBFHinv(const double sqrt_s) const
Definition: NPbase.h:2749
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1651
virtual const double muTHUggHgaga(const double sqrt_s) const
Definition: NPbase.h:2524
virtual const double muVHbb(const double sqrt_s) const
Definition: NPbase.h:1667
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4082
virtual const double muTHUggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2598
virtual const double muttHgaga(const double sqrt_s) const
Definition: NPbase.h:1438
virtual const double muTHUggHbb(const double sqrt_s) const
Definition: NPbase.h:2719
virtual const double muTHUWHgaga(const double sqrt_s) const
Definition: NPbase.h:2537
virtual const double muWHmumu(const double sqrt_s) const
Definition: NPbase.h:1591
virtual const double muZHZZ(const double sqrt_s) const
Definition: NPbase.h:1478
virtual const double muttHZZ(const double sqrt_s) const
Definition: NPbase.h:1490
virtual const double deltaGammaHbbRatio1() const
Definition: NPbase.h:1810
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1045
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:4154
virtual const double muWHZZ(const double sqrt_s) const
Definition: NPbase.h:1482
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: NPbase.h:2383
virtual const double muggHtautau(const double sqrt_s) const
Definition: NPbase.h:1615
virtual const double muttHmumu(const double sqrt_s) const
Definition: NPbase.h:1599
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3568
virtual const double muggHZZ(const double sqrt_s) const
Definition: NPbase.h:1466
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2326
virtual const double muTHUVBFHWW(const double sqrt_s) const
Definition: NPbase.h:2627
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3938
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3275
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4037
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2393
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
Definition: NPbase.h:3473
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1989
virtual const double muVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:1623
virtual const double muTHUVHbb(const double sqrt_s) const
Definition: NPbase.h:2735
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1179
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1203
virtual const double delta_muVBF_2(const double sqrt_s) const
Definition: NPbase.h:1706
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3094
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
Definition: NPbase.h:3782
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4046
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: NPbase.h:1259
virtual const double muTHUggHZgamumu(const double sqrt_s) const
Definition: NPbase.h:2769
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3149
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3535
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1343
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3947
virtual const double muVHtautau(const double sqrt_s) const
Definition: NPbase.h:1635
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2313
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2175
virtual const double muttHZga(const double sqrt_s) const
Definition: NPbase.h:1462
virtual const double muTHUZHtautau(const double sqrt_s) const
Definition: NPbase.h:2703
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1969
virtual const double muVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:1422
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3839
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3586
virtual const double UpperLimitZgammaA(const double sqrt_s) const
Definition: NPbase.h:2430
virtual const double muTHUZHZga(const double sqrt_s) const
Definition: NPbase.h:2557
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1886
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2651
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1946
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1102
virtual const double delta_muZH_1(const double sqrt_s) const
Definition: NPbase.h:1720
virtual const double muVHmumu(const double sqrt_s) const
Definition: NPbase.h:1595
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3363
virtual const double muTHUVHmumu(const double sqrt_s) const
Definition: NPbase.h:2687
virtual const double cgminuscga() const
Definition: NPbase.h:2466
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
Definition: NPbase.h:3062
virtual const double delta_muggH_2(const double sqrt_s) const
Definition: NPbase.h:1697
virtual const double muTHUWHZZ(const double sqrt_s) const
Definition: NPbase.h:2585
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3884
virtual const double muTHUVHtautau(const double sqrt_s) const
Definition: NPbase.h:2711
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1078
virtual const double muppHZga(const double sqrt_s) const
Definition: NPbase.h:1687
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3246
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3265
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: NPbase.h:935
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: NPbase.h:1417
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2344
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: NPbase.h:901
virtual const double deltaGammaHWWRatio2() const
Definition: NPbase.h:1778
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4145
virtual const double muggHWW(const double sqrt_s) const
Definition: NPbase.h:1523
virtual const double cVplusctau() const
Definition: NPbase.h:2484
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2655
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3435
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1034
virtual const double delta_muWH_1(const double sqrt_s) const
Definition: NPbase.h:1711
virtual const double muTHUVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:2699
virtual const double muggHpbbH_HWW(const double sqrt_s) const
Definition: NPbase.h:1527
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4028
virtual const double delta_muWH_2(const double sqrt_s) const
Definition: NPbase.h:1715
virtual const double muttHbb(const double sqrt_s) const
Definition: NPbase.h:1671
virtual const double muVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1514
virtual const double muTHUWHZga(const double sqrt_s) const
Definition: NPbase.h:2561
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1237
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4100
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1166
virtual const double muTHUVBFHbb(const double sqrt_s) const
Definition: NPbase.h:2723
virtual const double muTHUWHmumu(const double sqrt_s) const
Definition: NPbase.h:2683
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3983
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1114
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3285
virtual const double muTHUZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2606
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4055
virtual const double muttHptH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1603
virtual const double muVHgaga(const double sqrt_s) const
Definition: NPbase.h:1434
virtual const double muttHptH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1675
virtual const double muTHUttHmumu(const double sqrt_s) const
Definition: NPbase.h:2691
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4109
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3237
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1979
virtual const double muTHUggHmumu(const double sqrt_s) const
Definition: NPbase.h:2671
virtual const double muZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1506
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3526
virtual const double muTHUZHWW(const double sqrt_s) const
Definition: NPbase.h:2631
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1355
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3920
virtual const double muTHUVHZga(const double sqrt_s) const
Definition: NPbase.h:2565
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
unsigned int fstate
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_had_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
unsigned int fstate
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
Definition: ThObservable.h:25
const StandardModel & getModel()
A get method to get the model.
Definition: ThObservable.h:100
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
const NPbase * myNPbase
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
const NPbase * myNPbase
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const NPbase * myNPbase
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
double computeThValue()
const NPbase * myNPbase
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double Pol_em
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeZHBRinvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mueeZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeZHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double Pol_em
const double sqrt_s
const double Pol_ep
mueeZHWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
mueeZHZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
mueeZHZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const double Pol_ep
mueeZHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mueeZHccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_ep
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZHgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double Pol_em
mueeZHggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
mueeZHinvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
mueeZHmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double Pol_ep
mueeZHssPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeZHtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
double computeThValue()
const double sqrt_s
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase